@meeovi/layer-commerce 1.0.6 → 1.0.8

package/app/composables/defs/extension.ts

@@ -1,236 +0,0 @@
-/* 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

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

package/app/composables/defs/types.ts

@@ -1,136 +0,0 @@
-/* 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

@@ -1,8 +0,0 @@
-export interface Product {
-  id: string
-  title: string
-  description: string
-  images: string[]
-  price: Price
-  variants?: ProductVariant[]
-}

package/app/composables/helpers/contextualizedNormalizers.feature

@@ -1,14 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

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

package/app/composables/index.ts

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

package/app/composables/methods/auth.ts

@@ -1,83 +0,0 @@
-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>;