@meeovi/layer-commerce 1.0.10 → 1.0.13

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/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 "type-fest";
+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,8 @@
+export interface Product {
+  id: string
+  title: string
+  description: string
+  images: string[]
+  price: Price
+  variants?: ProductVariant[]
+}

package/app/composables/helpers/contextualizedNormalizers.feature

@@ -0,0 +1,14 @@
+Feature: Contextualized normalizers
+
+  Scenario: Context is passed to normalizers
+    Given a normalizer that requires a context as a second argument
+    When toContextualizedNormalizers function is called
+    And the normalizer is called with just an input
+    Then the normalizer should also receive the context
+
+  Scenario: Context changes
+    Given a normalizer that requires a context as a second argument
+    When toContextualizedNormalizers function is called
+    And the context changes
+    And the normalizer is called with just an input
+    Then the normalizer should use the recent version of the context

package/app/composables/helpers/contextualizedNormalizers.test.ts

@@ -0,0 +1,85 @@
+import { defineFeature, loadFeature } from "jest-cucumber";
+import type { ContextualizedNormalizers } from "./contextualizedNormalizers";
+import { toContextualizedNormalizers } from "./contextualizedNormalizers";
+import type { SfMoney } from "../models";
+import { beforeEach, expect, vi } from "vitest";
+
+const feature = loadFeature("./contextualizedNormalizers.feature", { loadRelativePath: true });
+
+defineFeature(feature, (test) => {
+  type TestContext = {
+    locale: string;
+    currency: string;
+  };
+  type Normalizers = {
+    normalizeMoney(context: TestContext, input: number): SfMoney;
+  };
+  let testNormalizers: Normalizers;
+  let output: ContextualizedNormalizers<Normalizers>;
+  let context: TestContext;
+
+  beforeEach(() => {
+    context = {
+      currency: "USD",
+      locale: "en",
+    };
+  });
+
+  test("Context is passed to normalizers", ({ given, when, and, then }) => {
+    given("a normalizer that requires a context as a second argument", () => {
+      testNormalizers = {
+        normalizeMoney: vi.fn((context, input) => {
+          return {
+            amount: input,
+            currency: context.currency,
+            precisionAmount: input.toFixed(2),
+          };
+        }),
+      };
+    });
+
+    when("toContextualizedNormalizers function is called", () => {
+      output = toContextualizedNormalizers(testNormalizers, () => context);
+    });
+
+    and("the normalizer is called with just an input", () => {
+      output.normalizeMoney(100);
+    });
+
+    then("the normalizer should also receive the context", () => {
+      expect(testNormalizers.normalizeMoney).toHaveBeenCalledWith(context, 100);
+    });
+  });
+  test("Context changes", ({ given, when, and, then }) => {
+    given("a normalizer that requires a context as a second argument", () => {
+      testNormalizers = {
+        normalizeMoney: vi.fn((context, input) => {
+          return {
+            amount: input,
+            currency: context.currency,
+            precisionAmount: input.toFixed(2),
+          };
+        }),
+      };
+    });
+
+    when("toContextualizedNormalizers function is called", () => {
+      output = toContextualizedNormalizers(testNormalizers, () => context);
+    });
+
+    and("the context changes", () => {
+      context.currency = "EUR";
+    });
+
+    and("the normalizer is called with just an input", () => {
+      output.normalizeMoney(100);
+    });
+
+    then("the normalizer should use the recent version of the context", () => {
+      expect(testNormalizers.normalizeMoney).toHaveBeenCalledWith(
+        expect.objectContaining({ currency: "EUR" }),
+        expect.anything(),
+      );
+    });
+  });
+});

package/app/composables/helpers/contextualizedNormalizers.ts

@@ -0,0 +1,20 @@
+import type { NormalizersConstraint } from "../defs";
+
+export type ContextualizedNormalizers<TNormalizers extends NormalizersConstraint> = {
+  [TKey in keyof TNormalizers]: (
+    input: Parameters<TNormalizers[TKey]>[1],
+  ) => ReturnType<TNormalizers[TKey]>;
+};
+
+export function toContextualizedNormalizers<
+  TNormalizers extends NormalizersConstraint,
+  TNormalizerContext extends Record<string, any>,
+>(
+  normalizers: TNormalizers,
+  getContext: () => TNormalizerContext,
+): ContextualizedNormalizers<TNormalizers> {
+  return Object.keys(normalizers).reduce((acc: any, key) => {
+    acc[key] = (input: any) => normalizers[key]!(getContext(), input);
+    return { ...acc };
+  }, {});
+}

package/app/composables/helpers/index.ts

@@ -0,0 +1 @@
+export * from "./contextualizedNormalizers";

package/app/composables/index.ts

@@ -0,0 +1,6 @@
+export * from "./defs";
+export * from "./helpers";
+export * from "./methods";
+export * from "./models";
+export * from "./validationRules";
+export * from "./registry";

package/app/composables/methods/auth.ts

@@ -0,0 +1,83 @@
+import type { Simplify } from "type-fest";
+import type { Maybe, SfCustomer } from "../models";
+
+export interface RegisterCustomerExtendedArgs {}
+export interface RegisterCustomerCustomArgs {}
+
+export type RegisterCustomerArgs = {
+  email: string;
+  firstName: string;
+  lastName: string;
+  password: string;
+  //$extended?: RegisterCustomerExtendedArgs;
+  //$custom?: RegisterCustomerCustomArgs;
+};
+
+export type RegisterCustomer = (args: Simplify<RegisterCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface LoginCustomerExtendedArgs {}
+export interface LoginCustomerCustomArgs {}
+
+export type LoginCustomerArgs = {
+  email: string;
+  password: string;
+  //$extended?: LoginCustomerExtendedArgs;
+  //$custom?: LoginCustomerCustomArgs;
+};
+
+export type LoginCustomer = (args: Simplify<LoginCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface GetCustomerExtendedArgs {}
+export interface GetCustomerCustomArgs {}
+
+export type GetCustomerArgs = {
+  //$extended?: GetCustomerExtendedArgs;
+  //$custom?: GetCustomerCustomArgs;
+};
+
+export type GetCustomer = (args?: Simplify<GetCustomerArgs>) => Promise<{
+  customer: Maybe<SfCustomer>;
+}>;
+
+export interface LogoutCustomerExtendedArgs {}
+export interface LogoutCustomerCustomArgs {}
+
+export type LogoutCustomerArgs = {
+  //$extended?: LogoutCustomerExtendedArgs;
+  //$custom?: LogoutCustomerCustomArgs;
+};
+
+export type LogoutCustomer = (args?: Simplify<LogoutCustomerArgs>) => Promise<void>;
+
+export interface UpdateCustomerExtendedArgs {}
+export interface UpdateCustomerCustomArgs {}
+
+export type UpdateCustomerArgs = {
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  //$extended?: UpdateCustomerExtendedArgs;
+  //$custom?: UpdateCustomerCustomArgs;
+};
+
+export type UpdateCustomer = (args: Simplify<UpdateCustomerArgs>) => Promise<{
+  customer: SfCustomer;
+}>;
+
+export interface ChangeCustomerPasswordExtendedArgs {}
+export interface ChangeCustomerPasswordCustomArgs {}
+
+export type ChangeCustomerPasswordArgs = {
+  currentPassword: string;
+  // eslint-disable-next-line unicorn/no-keyword-prefix
+  newPassword: string;
+  confirmPassword: string;
+  //$extended?: ChangeCustomerPasswordExtendedArgs;
+  //$custom?: ChangeCustomerPasswordCustomArgs;
+};
+
+export type ChangeCustomerPassword = (args: Simplify<ChangeCustomerPasswordArgs>) => Promise<void>;