-
-
-
diff --git a/docs/content/3.middleware/2.guides/10.logging.md b/docs/content/3.middleware/2.guides/10.logging.md
deleted file mode 100644
index ea5fb38332..0000000000
--- a/docs/content/3.middleware/2.guides/10.logging.md
+++ /dev/null
@@ -1,344 +0,0 @@
-# Logger
-
-The middleware application provides a logger instance that automatically attaches metadata related to the scope of each call. By adding this contextual data, the logger makes it significantly easier to trace the origin of logs or errors, simplifying the debugging and monitoring process across the application.
-
-:::info
-The logger has been available since version 5.1.0. Please refer to the [middleware changelog](https://docs.alokai.com/middleware/reference/change-log#_510) for more details.
-:::
-
-## Using logger
-
-The middleware application provides access to the logger in various parts of the system, such as in extensions and integrations. This flexibility allows you to log important events, errors, and other data throughout the lifecycle of your application.
-
-In this section, we will explore how to access and use the logger in different parts of the application.
-
-The examples below demonstrate how to use the application logger to ensure that correct metadata is conveyed in the logs. To achieve that, we will use the `getLogger` function to extract the logger instance from the passed argument.
-
-:::tip
-The logger is integrated into the middleware to provide additional metadata about the scope of call with every log out of the box. In case of error, it also provides an error boundary.
-:::
-
-### Basic Logger usage
-
-To use the logger, you need to import the `getLogger` function from the middleware package. Depending on the context, you can obtain the logger from different sources, such as the `alokai` object, `context` object, or `params` object. All such cases are covered in the following examples. For this example, we will use the `context` object.
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-// Assume that `context` is available in the current scope
-const logger = getLogger(context);
-logger.info("Middleware is running!");
-```
-
-Prints:
-
-```json
-{
- "message": "Middleware is running!",
- "timestamp": "2024-10-22T19:04:18.791Z",
- "severity": "INFO",
- "alokai": {
- "context": "middleware",
- "scope": {
- // ...
- }
- }
-}
-```
-
-The provided logger has a second optional argument that allows you to include custom metadata to be attached to the JSON output.
-For example:
-
-```ts
-logger.info("I've just fetched a user!", {
- userId: "123",
-});
-```
-
-Prints:
-
-```json
-{
- "message": "I've just fetched a user!",
- "timestamp": "2024-10-22T19:04:18.791Z",
- "severity": "INFO",
- "alokai": {
- "context": "middleware",
- "scope": {
- // ...
- }
- },
- "userId": "123"
-}
-```
-
-:::warning
-It's forbidden to overwrite **alokai** key within provided metadata. Any attempt will be ineffective. If you need to provide additional metadata, use a different key. **alokai** key is reserved for internal use only.
-:::
-
-### `extendApp`
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-const someExtension = {
- name: "some-extension",
- extendApp(params) {
- const logger = getLogger(params);
-
- logger.info(
- "You can call a logger inside extendApp hook, called on bootstrap of the application"
- );
- },
-};
-```
-
-### Hooks
-
-Logger is available in hooks factory:
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-const paypalExtension = {
- name: "sapcc-paypal-extension",
- hooks(req, res, alokai) {
- const logger = getLogger(alokai);
- logger.info(
- "You can call a logger every time a hooks factory gets invoked"
- );
- return {
- // ...
- };
- },
-};
-```
-
-In order, to use logger in certain hooks like `beforeCall`, `beforeCreate`, `afterCall`, `afterCreate` obtain it from it's params:
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-const paypalExtension = {
- name: "sapcc-paypal-extension",
- hooks(req, res, alokai) {
- return {
- beforeCall(params) {
- const logger = getLogger(params);
- logger.info("You can log every time a beforeCall hook gets invoked");
- return params.args;
- },
- beforeCreate(params) {
- const logger = getLogger(params);
- logger.info("You can log every time a beforeCreate hook gets invoked");
- return params.configuration;
- },
- afterCall(params) {
- const logger = getLogger(params);
- logger.info("You can log every time a afterCall hook gets invoked");
- return params.response;
- },
- afterCreate(params) {
- const logger = getLogger(params);
- logger.info("You can log every time a afterCreate hook gets invoked");
- return params.configuration;
- },
- };
- },
-};
-```
-
-#### Caveat: Accessing logger via closure
-
-Consider the following snippet:
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-const someExtension = {
- name: "some-extension",
- hooks(req, res, alokai) {
- const hooksLogger = getLogger(alokai);
- hooksLogger.info(
- "You can call a logger every time a hooks factory gets invoked"
- );
- return {
- beforeCall(params) {
- // Never access via closure a logger belonging to the hooks factory:
- hooksLogger.info("Don't do that!");
- // Instead use own logger of every hook function:
- const logger = getLogger(params);
- logger.info("Do that!");
- return params.args;
- },
- };
- },
-};
-```
-
-:::warning
-Attempt of using `hooksLogger` inside `beforeCall` or other hooks via closure corrupts information about scope of call of the log. Always use logger provided in params to the hook.
-:::
-
-### extendApiMethods
-
-Inside extended api methods, obtain logger from `context` using `getLogger` function.
-
-```ts
-import { getLogger } from "@vue-storefront/middleware";
-
-const testingExtension = {
- name: "some-extension",
- extendApiMethods: {
- addedCustomEndpoint(context) {
- const logger = getLogger(context);
- logger.info("You can log inside newly created handler!");
- return {
- // ...
- };
- },
- },
-};
-```
-
-:::tip
-You can derive logger from context the same way if you are creating an integration.
-:::
-
-### onCreate
-
-The hook got a new parameter from which you can derive the logger with help of `getLogger` function.
-
-```ts
-import { type AlokaiContainer, getLogger } from "@vue-storefront/middleware";
-
-const onCreate = async (
- config: Record
-
-## Use Cases
-
-### Adding an Endpoint
-
-To register a new API endpoint, you can register a custom extension and use the `extendApiMethods` property. API
-endpoints cannot be registered directly. Let's look at an example:
-
-```ts
-export const integrations = {
- sapcc: {
- // ...
- extensions: (extensions) => [
- ...extensions,
- {
- name: "example-extension",
- extendApiMethods: {
- baseSites: async (context) => {
- // Using integration's HTTP client to make a request to SAP Commerce Cloud backend
- // SAPCC integration is using `axios` as an HTTP client, so we want to retreive only the `data` property from the response.
- const { data } = await context.client.get("/basesites");
- return data;
- },
- },
- },
- ],
- },
-};
-```
-
-All integrations can be extended, however, this example extends the SAP Commerce Cloud integration, to give more context about real-life usage. We registered `baseSites` in `extendApiMethods` which creates a new `/api/sapcc/baseSites` endpoint.
-
-This method accepts two parameters:
-
-- `context` - integration context which includes:
- - `config` - integration configuration
- - `client` - HTTP client used by the integration
- - `req` - HTTP request object
- - `res` - HTTP response object
- - `extensions` - extensions registered within an integration
- - `customQueries` - custom GraphQL queries registered within integration (used only with GraphQL)
- - `extendQuery` - helper function for handling custom queries (used only with GraphQL)
-- `params` - parameters passed in the request's body
-
-#### Using extension methods in the frontend
-
-To call the extension endpoint, you should use the [middlewareModule](/sdk/getting-strated/middlewareModule).
-
-First, you need to prepare the type definition for the extension methods. It will be necessary to pass this type to the `middlewareModule`. To do it, let's aggregate the extension methods in a single object:
-
-```typescript [storefront-middleware/middleware.config.ts]
-export const extensionMethods = {
- baseSites: async (context, params) => {
- const { data } = await context.client.get("/basesites");
- return data;
- },
-};
-
-export const integrations = {
- sapcc: {
- location: "@vsf-enterprise/sapcc-api/server",
- configuration: {
- // ...
- },
- extensions: (extensions) => [
- ...extensions,
- {
- name: "example-extension",
- extendApiMethods: {
- ...extensionMethods,
- },
- },
- ],
- },
-};
-```
-
-Then, let's use the `WithoutContext` type helper to prepare the type of the endpoints created by the extension methods. As a good practice, it's recommended to use a separate file for the types used in the middleware configuration:
-
-```typescript [storefront-middleware/types.ts]
-import { type WithoutContext } from "@vue-storefront/middleware";
-import { extensionMethods } from "./middleware.config";
-
-export { type Endpoints as SapccEndpoints } from "@vsf-enterprise/sapcc-api";
-export type ExtensionEndpoints = WithoutContext
-
- );
-}
-```
-
-The same approach can be used in hooks or any other components.
-
-#tab-2
-
-## Installation
-
-To use the State Manager within Nuxt, you need to have the `@vue-storefront/nuxt` package installed. This step is already done if you have followed the [getting started](/sdk/getting-started). If not, you'll find installation instructions there.
-
-## Usage
-
-To use it you don't need to do anything special. Just use the auto-imported `useSfState` composable in your components or composables. You can use parts of the state as refs so you can read and write to them easily. As mentioned before, the state is based on Pinia. To read more on how to use it, please refer to the [official documentation](https://pinia.vuejs.org/).
-
-Example usage of state management:
-
-```vue
-
- Cart total: {cart.total}
-- Customer name: {customer.firstName} {customer.lastName} -
-Currency: {currency}
-Locale: {locale}
-
-
-
-
-
-```
-
-The same approach can be used in composables or any other components.
-
-::
diff --git a/docs/content/4.sdk/2.getting-started/3.middleware-module.md b/docs/content/4.sdk/2.getting-started/3.middleware-module.md
deleted file mode 100644
index f25b9bcf99..0000000000
--- a/docs/content/4.sdk/2.getting-started/3.middleware-module.md
+++ /dev/null
@@ -1,512 +0,0 @@
-# The `middlewareModule`
-
-## Introduction
-
-The `middlewareModule` is an SDK module that ensures communication with the [Server Middleware](/middleware).
-
-## Setup
-
-Depending on which framework you are using, you can get the `middlewareModule` in different ways. However, the setup is always the same.
-
-In Next, `middlewareModule` is available in the `createSdk` function.
-
-```ts [Next]
-// sdk/sdk.config.ts
-import { CreateSdkOptions, createSdk } from "@vue-storefront/next";
-import { UnifiedEndpoints } from "storefront-middleware/types";
-
-const options: CreateSdkOptions = {
- middleware: {
- apiUrl: "http://localhost:4000",
- },
-};
-
-export const { getSdk } = createSdk(
- options,
- ({ buildModule, config, middlewareModule, getRequestHeaders }) => ({
- commerce: buildModule(middlewareModuleCart total: {{ cart.total }}
-Customer name: {{ customer.firstName }} {{ customer.lastName }}
-Currency: {{ currency }}
-Locale: {{ locale }}
-
-
-