@vue-storefront/nuxt 0.0.0-20250722194236

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Vue Storefront
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# @vue-storefront/nuxt
+
+## Quick Setup
+
+1. Add `@vue-storefront/nuxt` dependency to your project
+
+```bash
+# Using pnpm
+pnpm add -D @vue-storefront/nuxt
+
+# Using yarn
+yarn add --dev @vue-storefront/nuxt
+
+# Using npm
+npm install --save-dev @vue-storefront/nuxt
+```
+
+2. Add `@vue-storefront/nuxt` to the `modules` section of `nuxt.config.ts`
+
+```js
+export default defineNuxtConfig({
+  modules: ["@vue-storefront/nuxt"],
+});
+```
+
+3. Configure the module
+
+To configure the module, use `vsf` key in the Nuxt configuration object and provide necessary information such as the Middleware instance address:
+
+```ts
+export default defineNuxtConfig({
+  modules: ["@vue-storefront/nuxt"],
+  vsf: {
+    middleware: {
+      apiUrl: "http://localhost:4000",
+    },
+  },
+});
+```
+
+4. Create SDK config file - `sdk.config.ts` in root directory of your project:
+
+The `defineSdkConfig` function is used for this purpose. The parameter for calling this function should be an anonymous function that receives an injected context from the module, containing:
+
+- the `buildModule` function,
+- the middleware URL (`middlewareUrl`),
+- a function for retrieving the Cookie header with cookie values (`getCookieHeader`).
+
+You should import all other SDK configuration components. See the example below illustrating the SDK configuration with Unified and Contentful modules.
+
+```ts
+import {
+  contentfulModule,
+  ContentfulModuleType,
+} from "@vsf-enterprise/contentful-sdk";
+import { unifiedModule } from "@vsf-enterprise/unified-sdk";
+import type { UnifiedApiExtension } from "../storefront-middleware/middleware.config";
+
+export default defineSdkConfig(
+  ({ buildModule, middlewareUrl, getCookieHeader }) => ({
+    unified: buildModule(unifiedModule<UnifiedApiExtension>, {
+      apiUrl: middlewareUrl + "/commerce",
+      requestOptions: {
+        headers: getCookieHeader,
+      },
+    }),
+    contentful: buildModule<ContentfulModuleType>(contentfulModule, {
+      apiUrl: middlewareUrl + "/cntf",
+    }),
+  }),
+);
+```
+
+That's it! You can now use VueStorefront Module in your Nuxt app ✨

package/dist/module.d.mts

@@ -0,0 +1,43 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface MiddlewareConfig {
+    /**
+     * The URL of the middleware.
+     * @example "http://localhost:4000"
+     */
+    apiUrl: string;
+    /**
+     * This is identifier used to invalidate the cache on CDN when the assets change.
+     * Usually it's a commit hash.
+     * @example "2c106d9619c71c3082c9b59b1d72817363c8ecb9"
+     * @default "no-cache-busting-id-set"
+     */
+    cdnCacheBustingId?: string;
+    /**
+     * The URL of the middleware for server-side rendering.
+     * @example "http://localhost:4000"
+     */
+    ssrApiUrl: string;
+}
+interface MultistoreConfig {
+    /**
+     * Whether the multistore is enabled or not.
+     * @example false
+     * @default false
+     */
+    enabled: boolean;
+}
+type LogVerbosity = "alert" | "critical" | "debug" | "emergency" | "error" | "info" | "notice" | "warning";
+type LoggerOptions = Partial<{
+    includeStackTrace: boolean;
+    verbosity: LogVerbosity;
+}>;
+interface AlokaiModuleOptions {
+    logger?: LoggerOptions;
+    middleware: MiddlewareConfig;
+    multistore?: MultistoreConfig;
+}
+
+declare const _default: _nuxt_schema.NuxtModule<AlokaiModuleOptions, AlokaiModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "compatibility": {
+    "nuxt": "^3.0.0"
+  },
+  "configKey": "alokai",
+  "name": "@vue-storefront/nuxt",
+  "version": "9.1.0-next.2",
+  "builder": {
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.5.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,160 @@
+import { defineNuxtModule, createResolver, installModule, addTypeTemplate, addImports, addTemplate, addPluginTemplate, addImportsSources, addServerHandler } from '@nuxt/kit';
+import { defu } from 'defu';
+import { genInlineTypeImport } from 'knitwork';
+
+const RUNTIME_CONFIG = {
+  public: {}
+};
+const module = defineNuxtModule({
+  defaults: {
+    logger: {
+      includeStackTrace: false,
+      verbosity: "debug"
+    },
+    middleware: {
+      apiUrl: "",
+      cdnCacheBustingId: "no-cache-busting-id-set",
+      ssrApiUrl: ""
+    },
+    multistore: {
+      enabled: false
+    }
+  },
+  meta: {
+    compatibility: {
+      nuxt: "^3.0.0"
+    },
+    configKey: "alokai",
+    name: "@vue-storefront/nuxt"
+  },
+  async setup(options, nuxt) {
+    const projectLayer = nuxt.options._layers[0];
+    const projectRootResolver = createResolver(projectLayer.config.rootDir);
+    const buildDirectoryResolver = createResolver(nuxt.options.buildDir);
+    const localResolver = createResolver(import.meta.url);
+    await installModule("@pinia/nuxt");
+    nuxt.options.runtimeConfig.public.alokai = defu(
+      nuxt.options.runtimeConfig.public?.alokai,
+      options
+    );
+    Object.assign(
+      nuxt.options.appConfig,
+      defu(nuxt.options.appConfig, {
+        alokaiVersion: process.env.NUXT_PUBLIC_ALOKAI_VERSION
+      })
+    );
+    Object.assign(
+      nuxt.options.runtimeConfig,
+      defu(nuxt.options.runtimeConfig, RUNTIME_CONFIG)
+    );
+    nuxt.options.app.head.meta = [
+      ...nuxt.options.app.head.meta ?? [],
+      {
+        content: "Alokai Storefront",
+        name: "generator"
+      }
+    ];
+    nuxt.hooks.hook("nitro:config", async (nitroConfig) => {
+      nitroConfig.externals = nitroConfig.externals || {};
+      nitroConfig.externals.inline = nitroConfig.externals.inline || [];
+      nitroConfig.externals.inline.push(localResolver.resolve("./runtime"));
+    });
+    addTypeTemplate({
+      filename: "sdk.config.d.ts",
+      getContents: () => `
+export type SdkConfig = ${genInlineTypeImport(
+        projectRootResolver.resolve("sdk.config")
+      )}
+      `
+    });
+    addTypeTemplate({
+      filename: "alokaiModule.d.ts",
+      src: localResolver.resolve("./runtime/types.template")
+    });
+    addImports({
+      as: "getDefaultMethodsRequestConfig",
+      from: localResolver.resolve("./runtime/utils/defaults"),
+      name: "getDefaultMethodsRequestConfig"
+    });
+    addTemplate({
+      filename: "useSdk.ts",
+      src: localResolver.resolve("./runtime/useSdk.template"),
+      write: true
+    });
+    addTemplate({
+      filename: "defineSdkConfig.ts",
+      options: {
+        moduleConfig: JSON.stringify(options)
+      },
+      src: localResolver.resolve("./runtime/defineSdkConfig.template"),
+      write: true
+    });
+    addTemplate({
+      filename: "defineGetConfigSwitcherHeader.ts",
+      options: {
+        moduleConfig: JSON.stringify(options)
+      },
+      src: localResolver.resolve(
+        "./runtime/defineGetConfigSwitcherHeader.template"
+      ),
+      write: true
+    });
+    addTemplate({
+      filename: "useSfState.ts",
+      src: localResolver.resolve("./runtime/useSfState.template"),
+      write: true
+    });
+    addTemplate({
+      filename: "logger.ts",
+      options: {
+        moduleConfig: JSON.stringify(options)
+      },
+      src: localResolver.resolve("./runtime/logger.template"),
+      write: true
+    });
+    addTemplate({
+      filename: "errorHandler.ts",
+      src: localResolver.resolve("./runtime/errorHandler.template"),
+      write: true
+    });
+    addPluginTemplate({
+      filename: "alokaiPlugin.ts",
+      options: {
+        moduleConfig: JSON.stringify(options)
+      },
+      src: localResolver.resolve("./runtime/plugin.template"),
+      write: true
+    });
+    await installModule("@alokai/instrumentation-nuxt3-module");
+    addImportsSources([
+      {
+        from: buildDirectoryResolver.resolve("useSdk.ts"),
+        imports: ["useSdk"]
+      },
+      {
+        from: buildDirectoryResolver.resolve("defineSdkConfig.ts"),
+        imports: ["defineSdkConfig", "defineSdkModule"]
+      },
+      {
+        from: buildDirectoryResolver.resolve(
+          "defineGetConfigSwitcherHeader.ts"
+        ),
+        imports: ["defineGetConfigSwitcherHeader"]
+      },
+      {
+        from: buildDirectoryResolver.resolve("useSfState.ts"),
+        imports: ["useSfState"]
+      },
+      {
+        from: buildDirectoryResolver.resolve("logger.ts"),
+        imports: ["logger"]
+      }
+    ]);
+    addServerHandler({
+      handler: localResolver.resolve("./runtime/serverMiddleware"),
+      middleware: true
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/defineGetConfigSwitcherHeader.template

@@ -0,0 +1 @@
+export { defineGetConfigSwitcherHeader } from '@alokai/connect/sdk';

package/dist/runtime/defineSdkConfig.template

@@ -0,0 +1,193 @@
+import type { Extension, Module } from "@alokai/connect/sdk";
+import { buildModule, middlewareModule } from "@alokai/connect/sdk";
+import { useNuxtApp, useRequestHeaders, getDefaultMethodsRequestConfig } from "#imports";
+import type { Composer } from '#i18n';
+import type { AlokaiModuleOptions } from "./alokaiModule";
+
+type InjectedContext = {
+  buildModule: typeof buildModule;
+  middlewareModule: typeof middlewareModule;
+  /**
+   * @deprecated
+   * Use `getRequestHeaders` instead.
+   */
+  getCookieHeader: () => Record<string, string>;
+  getRequestHeaders: () => Record<string, string>;
+  /**
+   * @deprecated
+   * Use `config.defaults` instead.
+   */
+  defaults: ReturnType<typeof getDefaultMethodsRequestConfig>;
+  config: {
+    apiUrl: string;
+    ssrApiUrl: string;
+    defaultMethodsRequestConfig: ReturnType<typeof getDefaultMethodsRequestConfig>;
+    cdnCacheBustingId: string;
+  };
+};
+
+type Config<TConfig> = (context: InjectedContext) => TConfig;
+
+const moduleConfig: AlokaiModuleOptions = <%= options.moduleConfig %>;
+
+/**
+  * Define SDK config function
+  *
+  * @param config - Function that returns SDK config or a record of SDK modules
+  *
+  * @example Using a function:
+  * ```ts
+  * import type { UnifiedEndpoints } from 'storefront-middleware/types';
+  * import { getConfigSwitcherHeader } from './utils';
+  *
+  * export default defineSdkConfig(
+  *   ({ buildModule, middlewareModule, config, getRequestHeaders }) => ({
+  *     unified: buildModule(middlewareModule<UnifiedEndpoints>, {
+  *       apiUrl: config.apiUrl + "/commerce/unified",
+  *       ssrApiUrl: config.ssrApiUrl + "/commerce/unified",
+  *       cdnCacheBustingId: config.cdnCacheBustingId,
+  *       defaultRequestConfig: {
+  *         getConfigSwitcherHeader,
+  *         headers: getRequestHeaders(),
+  *       },
+  *       methodsRequestConfig: config.defaultMethodsRequestConfig.unifiedCommerce.middlewareModule,
+  *     }),
+  *   }),
+  * );
+  * ```
+  *
+  * @example Using a record of modules:
+  * ```ts
+  * import type { UnifiedEndpoints } from 'storefront-middleware/types';
+  * import { getConfigSwitcherHeader } from './utils';
+  *
+  * const unified = defineSdkModule(({ buildModule, config, getRequestHeaders, middlewareModule }) =>
+  *   buildModule(middlewareModule<UnifiedEndpoints>, {
+  *     apiUrl: config.apiUrl + "/commerce/unified",
+  *     ssrApiUrl: config.ssrApiUrl + "/commerce/unified",
+  *     cdnCacheBustingId: config.cdnCacheBustingId,
+  *     defaultRequestConfig: {
+  *       getConfigSwitcherHeader,
+  *       headers: getRequestHeaders(),
+  *     },
+  *     methodsRequestConfig: config.defaultMethodsRequestConfig.unifiedCommerce.middlewareModule,
+  *   }),
+  * );
+  *
+  * export default defineSdkConfig({
+  *   unified,
+  * });
+  * ```
+  */
+export function defineSdkConfig<TConfig>(config: Config<TConfig>): () => TConfig;
+export function defineSdkConfig<TModules extends Record<string, DefineSdkModule>>(
+  modules: TModules,
+): () => {
+  [K in keyof TModules]: ReturnType<TModules[K]>;
+};
+export function defineSdkConfig<TConfig>(
+  config: Config<TConfig> | Record<string, DefineSdkModule>,
+) {
+  return () => {
+    const nuxtApp = useNuxtApp()
+    const runtimeConfig = useRuntimeConfig();
+
+    const requestHeaders = useRequestHeaders(["x-forwarded-host", "host"]);
+    const resolvedOptions = resolveOptions(runtimeConfig.public.alokai);
+
+    const getCookieHeader = () => useRequestHeaders(["cookie"]);
+    const getRequestHeaders = () => ({
+      "x-alokai-locale": (nuxtApp as unknown as { $i18n: Composer }).$i18n?.locale?.value,
+      ...useRequestHeaders()
+    });
+
+    const context = {
+      buildModule,
+      middlewareModule,
+      getCookieHeader,
+      getRequestHeaders,
+      defaults: getDefaultMethodsRequestConfig(),
+      config: {
+        apiUrl: resolvedOptions.middleware.apiUrl,
+        ssrApiUrl: resolvedOptions.middleware.ssrApiUrl,
+        defaultMethodsRequestConfig: getDefaultMethodsRequestConfig(),
+        cdnCacheBustingId: runtimeConfig.public.alokai.middleware.cdnCacheBustingId,
+      }
+    };
+
+    if (typeof config === 'function') {
+      return config(context);
+    }
+
+    return buildModules(config)(context);
+  }
+}
+
+type DefineSdkModule = (
+  context: InjectedContext,
+) => ReturnType<typeof buildModule>;
+
+/**
+  * Defines an SDK module that can be used with defineSdkConfig.
+  * Each module is a function that takes the InjectedContext and returns a built module.
+  *
+  * @param moduleDefinition - A function that takes InjectedContext and returns a built module
+  *
+  * @example
+  * ```ts
+  * import type { UnifiedEndpoints } from 'storefront-middleware/types';
+  * import { getConfigSwitcherHeader } from './utils';
+  *
+  * export const unified = defineSdkModule(({ buildModule, config, getRequestHeaders, middlewareModule }) =>
+  *   buildModule(middlewareModule<UnifiedEndpoints>, {
+  *     apiUrl: config.apiUrl + "/commerce/unified",
+  *     ssrApiUrl: config.ssrApiUrl + "/commerce/unified",
+  *     cdnCacheBustingId: config.cdnCacheBustingId,
+  *     defaultRequestConfig: {
+  *       getConfigSwitcherHeader,
+  *       headers: getRequestHeaders(),
+  *     },
+  *     methodsRequestConfig: config.defaultMethodsRequestConfig.unifiedCommerce.middlewareModule,
+  *   }),
+  * );
+  * ```
+  */
+export function defineSdkModule<TModuleDefinition extends DefineSdkModule>(
+  moduleDefinition: TModuleDefinition,
+) {
+  return moduleDefinition;
+}
+
+function buildModules<TModules extends Record<string, DefineSdkModule>>(
+  modules: TModules,
+) {
+  return (context: InjectedContext) =>
+    Object.fromEntries(
+      Object.entries(modules).map(([key, module]) => [key, module(context)]),
+    ) as {
+      [K in keyof TModules]: ReturnType<TModules[K]>;
+    };
+}
+
+/**
+ * Helper function to resolve the SDK options based on the configuration.
+ * 
+ * @privateRemarks
+ * For now this file only verifies the type of the input and simply returns it.
+ * However, in the future we might need it to perform true input resolution.
+ * 
+ * @param input - The options for creating the SDK.
+ * @param options - The configuration object, that allows to customize the API Url creation on enabled multistore.
+ *
+ * @returns The resolved SDK options.
+ */
+function resolveOptions(
+  input: Omit<AlokaiModuleOptions, 'logger'>,
+  _options: Partial<ResolveSdkOptionsConfig> = {}
+): AlokaiModuleOptions {
+  return input;
+}
+
+type ResolveSdkOptionsConfig = {
+  customSuffix: string;
+}

package/dist/runtime/errorHandler.template

@@ -0,0 +1,5 @@
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.hook('vue:error', (error) => {
+    logger.error(error);
+  });
+});

package/dist/runtime/logger.template

@@ -0,0 +1,37 @@
+import { LoggerFactory, LoggerType, type LoggerInterface } from "@alokai/connect/logger";
+import type { AlokaiModuleOptions, LoggerOptions } from "./alokaiModule";
+
+function injectMetadata(
+  logger: LoggerInterface,
+  externalData: Record<string, any>,
+): LoggerInterface {
+  return new Proxy(logger, {
+    get(target, prop) {
+      const targetProp = target[prop as keyof LoggerInterface];
+      if (typeof targetProp === "function") {
+        return (...args: Parameters<typeof targetProp>[]) => {
+          const [logData, metadata] = args;
+          targetProp(logData, {
+            ...metadata,
+            ...externalData,
+          });
+        };
+      }
+      return targetProp;
+    },
+  });
+}
+
+const moduleConfig: AlokaiModuleOptions = <%= options.moduleConfig %>;
+
+const createLogger = (options?: LoggerOptions) => {
+  const logger = LoggerFactory.create(LoggerType.ConsolaGcp, options);
+
+  return injectMetadata(logger, {
+    alokai: {
+      context: "storefront",
+    },
+  });
+};
+
+export const logger = createLogger(moduleConfig.logger);

package/dist/runtime/plugin.template

@@ -0,0 +1,16 @@
+import { initSDK, type SDKApi } from "@alokai/connect/sdk";
+import sdkConfig from "~/sdk.config";
+import type { SdkConfig } from "./sdk.config";
+import { defineNuxtPlugin } from '#app';
+
+export default defineNuxtPlugin((nuxtApp) => {
+  const getSdk: () => SDKApi<ReturnType<SdkConfig>> = () => {
+    return initSDK(sdkConfig());
+  };
+
+  return {
+    provide: {
+      alokai: { getSdk },
+    },
+  };
+});

package/dist/runtime/serverMiddleware.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, void>;
+export default _default;

package/dist/runtime/serverMiddleware.js

@@ -0,0 +1,6 @@
+import { defineEventHandler, getRequestURL } from "h3";
+export default defineEventHandler((event) => {
+  const { pathname, search } = getRequestURL(event);
+  event.node.req.headers["x-pathname"] = pathname;
+  event.node.req.headers["x-search"] = search;
+});

package/dist/runtime/types.template

@@ -0,0 +1,49 @@
+export interface MiddlewareConfig {
+  /**
+   * The URL of the middleware.
+   * @example "http://localhost:4000"
+   */
+  apiUrl: string;
+  /**
+   * The URL of the middleware for server-side rendering.
+   * @example "http://localhost:4000"
+   */
+  ssrApiUrl: string;
+  /**
+   * This is identifier used to invalidate the cache on CDN when the assets change.
+   * Usually it's a commit hash.
+   * @example "2c106d9619c71c3082c9b59b1d72817363c8ecb9"
+   * @default "no-cache-busting-id-set"
+   */
+  cdnCacheBustingId?: string;
+}
+
+export interface MultistoreConfig {
+  /**
+   * Whether the multistore is enabled or not.
+   * @example false
+   * @default false
+   */
+  enabled: boolean;
+}
+
+type LogVerbosity =
+  | "emergency"
+  | "alert"
+  | "critical"
+  | "error"
+  | "warning"
+  | "notice"
+  | "info"
+  | "debug";
+
+export type LoggerOptions = Partial<{
+  verbosity: LogVerbosity;
+  includeStackTrace: boolean;
+}>;
+
+export interface AlokaiModuleOptions {
+  middleware: MiddlewareConfig;
+  multistore?: MultistoreConfig;
+  logger?: LoggerOptions;
+}

package/dist/runtime/useSdk.template

@@ -0,0 +1,10 @@
+import type { SdkConfig } from "./sdk.config";
+import type { SDKApi } from '@alokai/connect/sdk';
+import { useNuxtApp } from "#imports";
+
+export const useSdk = () => {
+  const nuxtApp = useNuxtApp();
+  const { getSdk } = nuxtApp.$alokai as { getSdk: ()=> SDKApi<ReturnType<SdkConfig>> };
+
+  return getSdk();
+};

package/dist/runtime/useSfState.template

@@ -0,0 +1,17 @@
+import type {
+  SfCart,
+  SfCurrency,
+  SfCustomer,
+  SfLocale,
+} from "~/types";
+
+export const useSfState = defineStore("SfState", () => {
+  const cart = ref<SfCart | null>(null);
+  const customer = ref<SfCustomer | null>(null);
+  const currencies = ref<SfCurrency[]>([]);
+  const currency = ref<SfCurrency>();
+  const locale = ref<SfLocale>();
+  const locales = ref<SfLocale[]>([]);
+
+  return { customer, cart, currencies, currency, locales, locale };
+});

package/dist/runtime/utils/defaults.d.ts

@@ -0,0 +1,37 @@
+export declare function getDefaultMethodsRequestConfig(): {
+    readonly unifiedCms: {
+        readonly middlewareModule: {
+            readonly getEntries: {
+                readonly method: "GET";
+            };
+            readonly getPage: {
+                readonly method: "GET";
+            };
+        };
+    };
+    readonly unifiedCommerce: {
+        readonly middlewareModule: {
+            readonly getCategories: {
+                readonly method: "GET";
+            };
+            readonly getCategory: {
+                readonly method: "GET";
+            };
+            readonly getCurrencies: {
+                readonly method: "GET";
+            };
+            readonly getProductDetails: {
+                readonly method: "GET";
+            };
+            readonly getProductReviews: {
+                readonly method: "GET";
+            };
+            readonly getProducts: {
+                readonly method: "GET";
+            };
+            readonly searchProducts: {
+                readonly method: "GET";
+            };
+        };
+    };
+};

package/dist/runtime/utils/defaults.js

@@ -0,0 +1,21 @@
+export function getDefaultMethodsRequestConfig() {
+  return {
+    unifiedCms: {
+      middlewareModule: {
+        getEntries: { method: "GET" },
+        getPage: { method: "GET" }
+      }
+    },
+    unifiedCommerce: {
+      middlewareModule: {
+        getCategories: { method: "GET" },
+        getCategory: { method: "GET" },
+        getCurrencies: { method: "GET" },
+        getProductDetails: { method: "GET" },
+        getProductReviews: { method: "GET" },
+        getProducts: { method: "GET" },
+        searchProducts: { method: "GET" }
+      }
+    }
+  };
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@vue-storefront/nuxt",
+  "version": "0.0.0-20250722194236",
+  "description": "Alokai dedicated features for Nuxt",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "types": "./dist/types.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn prepare && nuxt-module-build build",
+    "lint": "yarn prepare && eslint",
+    "lint:fix": "yarn prepare && eslint --fix",
+    "format": "prettier --write .",
+    "prepare": "nuxi prepare",
+    "version": "cp CHANGELOG.md ../../docs/enterprise/content/storefront/6.change-log/nuxt.md"
+  },
+  "dependencies": {
+    "@alokai/instrumentation-nuxt3-module": "0.0.0-20250722194236",
+    "@nuxt/kit": "^3.7.4",
+    "@nuxt/schema": "^3.7.4",
+    "@pinia/nuxt": "^0.5.1",
+    "defu": "^6.0.0",
+    "knitwork": "^1.0.0",
+    "pinia": "^2.1.7"
+  },
+  "devDependencies": {
+    "@alokai/connect": "0.0.0-20250722194236",
+    "@nuxt/devtools": "1.7.0",
+    "@nuxt/module-builder": "1.0.1",
+    "@types/node": "^22.0.0",
+    "eslint": "9.23.0",
+    "nuxt": "3.13.2",
+    "prettier": "3.3.2"
+  },
+  "peerDependencies": {
+    "@alokai/connect": "0.0.0-20250722194236"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}