@mframework/layer-commerce 0.0.3

package/app/composables/defs/extension.test.ts

@@ -0,0 +1,280 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { DefineStepFunction } from "jest-cucumber";
+import { defineFeature, loadFeature } from "jest-cucumber";
+import { beforeEach, expect } from "vitest";
+import { unifiedExtensionFactory } from "./extension";
+import {
+  getAdditionalNormalizerContext,
+  methods,
+  normalizers,
+  rawMoneyMock,
+} from "./extension.mocks";
+import type { DefineAddCustomFields } from "./types";
+
+const feature = loadFeature("./extension.feature", {
+  loadRelativePath: true,
+});
+
+defineFeature(feature, (test) => {
+  let overrideNormalizers: Partial<typeof normalizers>;
+  let addCustomFields: [
+    DefineAddCustomFields<typeof normalizers>,
+    ...DefineAddCustomFields<typeof normalizers>[],
+  ];
+  let overrideApiMethods: Partial<typeof methods>;
+  const createUnifiedExtension = unifiedExtensionFactory<typeof methods, typeof normalizers, any>({
+    normalizers,
+    extendApiMethods: methods,
+    getAdditionalNormalizerContext,
+  });
+  let extension: ReturnType<typeof createUnifiedExtension>;
+
+  beforeEach(() => {
+    overrideNormalizers = {};
+    addCustomFields = [{}];
+    overrideApiMethods = {};
+  });
+
+  function whenTheExtensionIsCreated(when: DefineStepFunction) {
+    when("extension is created", () => {
+      extension = createUnifiedExtension({
+        normalizers: {
+          override: overrideNormalizers,
+          addCustomFields,
+        },
+        methods: {
+          override: overrideApiMethods,
+        },
+        config: {},
+      });
+    });
+  }
+
+  test("Overriding normalizer", ({ given, when, and, then }) => {
+    let result: any;
+
+    given("one of the normalizers is overridden", () => {
+      overrideNormalizers = {
+        normalizeMoney(rawMoney) {
+          return {
+            amount: rawMoney.amount,
+            currency: "USD",
+          };
+        },
+      };
+    });
+
+    whenTheExtensionIsCreated(when);
+
+    and("the normalizer is called", () => {
+      result = extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" });
+    });
+
+    then("the overridden normalizer should be called", () => {
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "amount": 10,
+          "currency": "USD",
+        }
+      `);
+    });
+
+    and("remaining normalizers should be unchanged", () => {
+      expect(extension.normalizers.normalizeProductCatalogItem).toBeDefined();
+    });
+  });
+  test("Add custom fields array with a single element", ({ given, when, and, then }) => {
+    let result: any;
+
+    given("a custom field is added to one of the normalizers", () => {
+      addCustomFields = [
+        {
+          normalizeMoney: ({ formattedAmount }) => ({
+            formattedAmount,
+          }),
+        },
+      ];
+    });
+
+    whenTheExtensionIsCreated(when);
+
+    and("the normalizer is called", () => {
+      result = extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" });
+    });
+
+    then("the custom field should be present in the $custom object", () => {
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "$custom": {
+            "formattedAmount": "10.00",
+          },
+          "amount": 10,
+          "currency": "PLN",
+        }
+      `);
+    });
+
+    and("remaining normalizers should be unchanged", () => {
+      expect(extension.normalizers.normalizeProductCatalogItem).toBeDefined();
+    });
+  });
+  test("Add custom fields array with multiple elements", ({ given, when, and, then }) => {
+    given("multiple elements of the addCustomFields array override the same normalizer", () => {
+      addCustomFields = [
+        {
+          normalizeMoney: ({ formattedAmount }) => ({
+            formattedAmount,
+          }),
+        },
+        {
+          normalizeMoney: ({ decimalPlaces }) => ({
+            decimalPlaces,
+          }),
+        },
+      ];
+    });
+
+    whenTheExtensionIsCreated(when);
+
+    and("the normalizer is called", () => {
+      extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" });
+    });
+
+    then("all custom fields should be present in the $custom object", () => {
+      expect(extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" }))
+        .toMatchInlineSnapshot(`
+          {
+            "$custom": {
+              "decimalPlaces": 2,
+              "formattedAmount": "10.00",
+            },
+            "amount": 10,
+            "currency": "PLN",
+          }
+        `);
+    });
+  });
+  test("Nested custom fields", ({ given, and, when, then }) => {
+    let result: any;
+
+    given("multiple elements of the addCustomFields array override the same normalizer", () => {
+      addCustomFields = [
+        {
+          normalizeMoney: () => ({
+            nested: {
+              nested_field1: "value1",
+              nestedLvl2: {
+                nestedLvl2_field1: "value1",
+              },
+            },
+          }),
+        },
+        {
+          normalizeMoney: () => ({
+            nested: {
+              nested_field2: "value2",
+            },
+            nested2: {
+              nested2_field1: "value3",
+            },
+          }),
+        },
+      ];
+    });
+
+    and("custom fields are objects", () => {});
+
+    whenTheExtensionIsCreated(when);
+
+    and("the normalizer is called", () => {
+      result = extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" });
+    });
+
+    then("objects should be merged into the $custom object", () => {
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "$custom": {
+            "nested": {
+              "nestedLvl2": {
+                "nestedLvl2_field1": "value1",
+              },
+              "nested_field1": "value1",
+              "nested_field2": "value2",
+            },
+            "nested2": {
+              "nested2_field1": "value3",
+            },
+          },
+          "amount": 10,
+          "currency": "PLN",
+        }
+      `);
+    });
+  });
+
+  test("Adding the same custom fields more than once", ({ given, when, and, then }) => {
+    let result: any;
+
+    given("multiple elements of the addCustomFields array add the same custom field", () => {
+      addCustomFields = [
+        {
+          normalizeMoney: ({ formattedAmount, decimalPlaces }) => ({
+            formattedAmount,
+            decimalPlaces,
+          }),
+        },
+        {
+          normalizeMoney: () => ({
+            formattedAmount: "overridden",
+          }),
+        },
+      ];
+    });
+
+    whenTheExtensionIsCreated(when);
+
+    and("the normalizer is called", () => {
+      result = extension.normalizers.normalizeMoney(rawMoneyMock, { currency: "PLN" });
+    });
+
+    then(
+      "the custom field should have value based on the last element of the addCustomFields array",
+      () => {
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "$custom": {
+              "decimalPlaces": 2,
+              "formattedAmount": "overridden",
+            },
+            "amount": 10,
+            "currency": "PLN",
+          }
+        `);
+      },
+    );
+  });
+
+  test("Overriding api method", ({ given, when, and, then }) => {
+    let result: any;
+
+    given("one of the api methods is overridden", () => {
+      overrideApiMethods = {
+        getSuccess: () => Promise.resolve({ ok: false }),
+      };
+    });
+
+    whenTheExtensionIsCreated(when);
+
+    and("the api method is called", async () => {
+      result = await extension.extendApiMethods.getSuccess();
+    });
+
+    then("the overridden api method should be called", () => {
+      expect(result).toMatchInlineSnapshot(`
+        {
+          "ok": false,
+        }
+      `);
+    });
+  });
+});

package/app/composables/defs/extension.ts

@@ -0,0 +1,236 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type ApiMethods = Record<string, (...args: any[]) => any>;
+
+interface ApiClientExtension {
+  name: string;
+  extendApiMethods?: Record<string, (...args: any[]) => any>;
+  hooks?: (req: any, res: any) => any;
+  isNamespaced?: boolean;
+}
+import { mergeDeepRight } from "ramda";
+import { toContextualizedNormalizers } from "../helpers";
+const Logger: any = console;
+import type {
+  BaseNormalizerContext,
+  CreateUnifiedExtensionParams,
+  DefineAddCustomFields,
+  GetAdditionalNormalizerContextConstraint,
+  GetAdditionalNormalizerContextParams,
+  NormalizersConstraint,
+  UnifiedCmsConfig,
+  UnifiedConfig,
+  UnifiedExtensionContextConstraint,
+  UnifiedExtensionFactoryParams,
+} from "./types";
+
+const CURRENCY_COOKIE = "vsf-currency";
+const LOCALE_COOKIE = "vsf-locale";
+
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A `createUnifiedExtension` function which can be used by the user to create a unified extension.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = unifiedExtensionFactory<
+ *   typeof apiMethods,
+ *   Normalizers,
+ *   Config
+ * >({
+ *   extendApiMethods: apiMethods,
+ *   normalizers,
+ * });
+ * ```
+ */
+export function unifiedExtensionFactory<
+  TApiMethods extends ApiMethods,
+  TNormalizers extends NormalizersConstraint,
+  TConfig extends UnifiedConfig,
+>(factoryParams: UnifiedExtensionFactoryParams<TApiMethods, TNormalizers>) {
+  return function createUnifiedExtension<
+    TAddCustomFieldsArray extends [
+      DefineAddCustomFields<TNormalizers>,
+      ...DefineAddCustomFields<TNormalizers>[],
+    ],
+  >(
+    params: CreateUnifiedExtensionParams<TConfig, TApiMethods, TNormalizers, TAddCustomFieldsArray>,
+  ) {
+    const {
+      extendApiMethods: defaultApiMethods,
+      normalizers: defaultNormalizers,
+      getAdditionalNormalizerContext,
+    } = factoryParams;
+    const baseNormalizers = { ...defaultNormalizers, ...params.normalizers.override };
+    const normalizers = mergeNormalizers(baseNormalizers, params.normalizers.addCustomFields);
+    const { config: extensionConfig, methods, isNamespaced = factoryParams.isNamespaced } = params;
+
+    return {
+      name: "unified",
+      extendApiMethods: {
+        ...defaultApiMethods,
+        ...methods?.override,
+      } as TApiMethods,
+      hooks(req: any, res: any) {
+        return {
+          beforeCall({ args, configuration }: { args: any; configuration: any }) {
+            if (!req.cookies[CURRENCY_COOKIE] && extensionConfig) {
+              req.cookies[CURRENCY_COOKIE] = extensionConfig.defaultCurrency;
+            }
+            configuration.unified = extensionConfig;
+            if (!configuration.normalizerContext) {
+              configuration.normalizerContext = createNormalizerContext(
+                normalizers,
+                getAdditionalNormalizerContext,
+                { req, res, config: configuration },
+              );
+              configuration.normalizerContext.currency =
+                req.cookies?.[CURRENCY_COOKIE] ?? extensionConfig.defaultCurrency ?? "USD";
+            }
+
+            return args;
+          },
+        };
+      },
+      isNamespaced,
+      normalizers,
+      /**
+       * @internal You shouldn't use this field. It's present only to infer the type of addCustomFields
+       */
+      _addCustomFields: {} as TAddCustomFieldsArray,
+    } satisfies ApiClientExtension & Record<string, any>;
+  };
+}
+
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A Middleware extension which can be registered in the API client.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = createUnifiedCmsExtension({
+ *   extendApiMethods: {
+ *     getPage,
+ *   },
+ *   normalizers,
+ *   getAdditionalNormalizerContext: () => ({
+ *     documentToHtmlString,
+ *   }),
+ * });
+ * ```
+ */
+export function createUnifiedCmsExtension<
+  TApiMethods extends ApiMethods,
+  TNormalizers extends NormalizersConstraint,
+>(params: UnifiedExtensionFactoryParams<TApiMethods, TNormalizers>) {
+  const {
+    extendApiMethods,
+    normalizers: defaultNormalizers,
+    getAdditionalNormalizerContext,
+    isNamespaced = true,
+  } = params;
+
+  return {
+    name: "unified",
+    extendApiMethods,
+    isNamespaced,
+    hooks(req: any, res: any) {
+      return {
+        beforeCall({ args, configuration }: { args: any; configuration: any }) {
+          if (!configuration.normalizerContext) {
+            const unifiedConfig = configuration?.unified ?? ({} as UnifiedCmsConfig<TNormalizers>);
+            const baseNormalizers = {
+              ...defaultNormalizers,
+              ...unifiedConfig.normalizers?.override,
+            };
+            const normalizers = mergeNormalizers(
+              baseNormalizers,
+              unifiedConfig.normalizers?.addCustomFields ?? [],
+            );
+
+            configuration.normalizerContext = createNormalizerContext(
+              normalizers,
+              getAdditionalNormalizerContext,
+              { req, res, config: configuration },
+            );
+          }
+          return args;
+        },
+      };
+    },
+  } satisfies ApiClientExtension;
+}
+
+/**
+ * A helper function to get the normalizers from the context.
+ * @param context Context passed to the API method
+ * @returns normalizers
+ *
+ * @example
+ * ```ts
+ * const { normalizeProduct } = getNormalizers(context);
+ * ```
+ */
+export function getNormalizers<TContext extends UnifiedExtensionContextConstraint>(
+  context: TContext,
+): TContext["config"]["normalizerContext"]["normalizers"] {
+  return context.config.normalizerContext.normalizers;
+}
+
+/**
+ * A helper function to assign values to the normalizer context.
+ * @param context Context passed to the API method
+ * @param overrides Object with the values to override in the normalizer context
+ * @returns void - it mutates the context
+ *
+ * @example
+ * ```ts
+ * assignToNormalizerContext(context, { locale: "de" });
+ * ```
+ */
+export function assignToNormalizerContext<TContext extends UnifiedExtensionContextConstraint>(
+  context: TContext,
+  overrides: Partial<TContext["config"]["normalizerContext"]>,
+) {
+  Object.assign(context.config.normalizerContext, overrides);
+}
+
+function createNormalizerContext<TNormalizers extends NormalizersConstraint>(
+  normalizers: TNormalizers,
+  getAdditionalNormalizerContext: GetAdditionalNormalizerContextConstraint,
+  { req, res, config }: GetAdditionalNormalizerContextParams,
+) {
+  const logger = Logger;
+  const normalizerContext: BaseNormalizerContext<TNormalizers> = {
+    locale: req.cookies?.[LOCALE_COOKIE] ?? "en",
+    ...getAdditionalNormalizerContext({ req, res, config }),
+    logger,
+  };
+  normalizerContext.normalizers = toContextualizedNormalizers(normalizers, () => normalizerContext);
+
+  return normalizerContext;
+}
+
+export function mergeNormalizers<TNormalizers extends NormalizersConstraint>(
+  baseNormalizers: TNormalizers,
+  addCustomFields: DefineAddCustomFields<TNormalizers>[],
+): TNormalizers {
+  const normalizers: any = { ...baseNormalizers };
+
+  addCustomFields.forEach((customFieldsNormalizers) => {
+    Object.entries(customFieldsNormalizers).forEach(([name, customFields]) => {
+      const currentNormalizer = normalizers[name]!;
+      if (normalizers[name] && customFields) {
+        normalizers[name] = (input: any, context: any) =>
+          mergeDeepRight(currentNormalizer(input, context), {
+            $custom: customFields(input, context),
+          });
+      }
+    });
+  });
+
+  return normalizers;
+}

package/app/composables/defs/index.ts

@@ -0,0 +1,3 @@
+export * from "./apiDefinitions";
+export * from "./extension";
+export * from "./types";

package/app/composables/defs/typeHelpers.ts

@@ -0,0 +1,8 @@
+// Minimal local type helpers to replace select `type-fest` utilities
+// These are intentionally small and conservative to keep type-checking stable
+
+export type Simplify<T> = { [K in keyof T]: T[K] } & {}
+
+export type MergeDeep<T, U> = T & U
+
+export {}

package/app/composables/defs/types.ts

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-use-before-define */
+type ApiMethods = Record<string, (...args: any[]) => any>;
+import type { MergeDeep } from './typeHelpers';
+import type { ContextualizedNormalizers } from "../helpers";
+import type { Maybe, SfCurrency, SfFacetType } from "../models";
+
+// Minimal local IntegrationContext replacement
+export interface IntegrationContext<CLIENT = any, CONFIG = any, API = any> {
+  client: CLIENT;
+  config: CONFIG;
+  api: API;
+  req?: any;
+  res?: any;
+  [x: string]: any;
+}
+
+export interface VSFLogger {
+  debug(message?: any, ...args: any[]): void;
+  info(message?: any, ...args: any[]): void;
+  warn(message?: any, ...args: any[]): void;
+  error(message?: any, ...args: any[]): void;
+}
+export interface UnifiedConfig {
+  currencies?: SfCurrency[];
+  defaultCurrency: SfCurrency;
+}
+
+export interface BaseNormalizerContext<TNormalizers extends NormalizersConstraint = any> {
+  locale: string;
+  currency: string;
+  normalizers: ContextualizedNormalizers<TNormalizers>;
+  logger: VSFLogger;
+}
+
+export type NormalizerConstraint<
+  TNormalizerContext extends BaseNormalizerContext = BaseNormalizerContext,
+> = (rawData: any, context: TNormalizerContext) => any;
+
+export type NormalizersConstraint<TNormalizerContext extends BaseNormalizerContext = any> = Record<
+  string,
+  NormalizerConstraint<TNormalizerContext>
+>;
+
+export type UnifiedExtensionContextConstraint<
+  TNormalizerContext extends BaseNormalizerContext = any,
+> = IntegrationContext & { config: { normalizerContext: TNormalizerContext } };
+
+export type GetFacetTypeFn<TInput> = (input: TInput) => Maybe<SfFacetType | string>;
+export type FilterFacetsFn<TInput> = (input: TInput) => boolean;
+
+export type GetAdditionalNormalizerContextParams<TConfig extends Record<string, any> = any> = {
+  req: IntegrationContext["req"];
+  res: IntegrationContext["res"];
+  config: TConfig;
+};
+
+export type GetAdditionalNormalizerContextConstraint = (
+  params: GetAdditionalNormalizerContextParams,
+) => any;
+
+export type GetAdditionalNormalizerContext<
+  TIntegrationContext extends IntegrationContext,
+  TNormalizerContext extends BaseNormalizerContext,
+> = (
+  params: GetAdditionalNormalizerContextParams<TIntegrationContext["config"]>,
+) => Omit<TNormalizerContext, keyof BaseNormalizerContext>;
+
+export interface AddCustomFields {}
+
+export type InferAddCustomFieldsFromArray<
+  TArray extends Record<string, (...args: any) => any>[],
+  TResult = {},
+> = TArray extends [
+  infer THead extends Record<string, (...args: any) => any>,
+  ...infer TTail extends Record<string, (...args: any) => any>[],
+]
+  ? InferAddCustomFieldsFromArray<
+      TTail,
+      MergeDeep<
+        TResult,
+        {
+          [TKey in keyof THead]: Exclude<ReturnType<THead[TKey]>, null | undefined>;
+        }
+      >
+    >
+  : TResult;
+
+export type InferAddCustomFields<TUnifiedExtension extends { _addCustomFields: any }> =
+  InferAddCustomFieldsFromArray<TUnifiedExtension["_addCustomFields"]>;
+
+export type InferCustom<TNormalizer extends string> =
+  AddCustomFields extends Record<TNormalizer, infer TCustom> ? TCustom : object;
+
+export type DefineAddCustomFields<TNormalizers extends NormalizersConstraint> = {
+  [Key in keyof TNormalizers]?: (...args: Parameters<TNormalizers[Key]>) => any;
+};
+
+export interface NormalizersConfig<
+  TNormalizers extends NormalizersConstraint,
+  TAddCustomFieldsArray,
+> {
+  override?: Partial<TNormalizers>;
+  addCustomFields: TAddCustomFieldsArray;
+}
+
+export interface UnifiedExtensionFactoryParams<
+  TApiMethods extends ApiMethods,
+  TNormalizers extends NormalizersConstraint,
+> {
+  normalizers: TNormalizers;
+  extendApiMethods: TApiMethods;
+  getAdditionalNormalizerContext: GetAdditionalNormalizerContextConstraint;
+  isNamespaced?: boolean;
+}
+
+export interface CreateUnifiedExtensionParams<
+  TConfig extends Record<string, any>,
+  TApiMethods extends ApiMethods,
+  TNormalizers extends NormalizersConstraint,
+  TAddCustomFieldsArray extends DefineAddCustomFields<TNormalizers>[],
+> {
+  config: TConfig;
+  normalizers: NormalizersConfig<TNormalizers, TAddCustomFieldsArray>;
+  methods?: {
+    override?: Partial<TApiMethods>;
+  };
+  isNamespaced?: boolean;
+}
+
+export interface UnifiedCmsConfig<
+  TNormalizers extends NormalizersConstraint,
+  TAddCustomFieldsArray = DefineAddCustomFields<TNormalizers>[],
+> {
+  normalizers?: NormalizersConfig<TNormalizers, TAddCustomFieldsArray>;
+}

package/app/composables/domain/product.ts

@@ -0,0 +1,12 @@
+import type { PriceType } from '../../types/Price.type'
+
+type ProductVariant = any
+
+export interface Product {
+  id: string
+  title: string
+  description: string
+  images: string[]
+  price: PriceType
+  variants?: ProductVariant[]
+}

package/app/composables/featured-products.ts

@@ -0,0 +1,20 @@
+import { useProducts } from './useProducts/useProducts'
+
+export function useFeaturedProducts() {
+  const { fetchProducts } = useProducts()
+  return {
+    async getFeaturedProducts(options: any = {}) {
+      const items = await fetchProducts()
+      // If fetchProducts returns a ref/computed, attempt to unwrap
+      // and filter by a common `featured` flag if present
+      try {
+        const list = (items as any)?.value ?? items
+        return (Array.isArray(list) ? list.filter((p: any) => p.featured || p.is_featured || p.isFeatured) : []) as any[]
+      } catch (e) {
+        return []
+      }
+    }
+  }
+}
+
+export default useFeaturedProducts