@meeovi/layer-commerce 1.0.5 → 1.0.7

package/dist/composables/defs/extension.js

@@ -1,154 +0,0 @@
-import { mergeDeepRight } from "ramda";
-import { toContextualizedNormalizers } from "../helpers";
-const Logger = console;
-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(factoryParams) {
-    return function createUnifiedExtension(params) {
-        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,
-            },
-            hooks(req, res) {
-                return {
-                    beforeCall({ args, configuration }) {
-                        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: {},
-        };
-    };
-}
-/**
- * @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(params) {
-    const { extendApiMethods, normalizers: defaultNormalizers, getAdditionalNormalizerContext, isNamespaced = true, } = params;
-    return {
-        name: "unified",
-        extendApiMethods,
-        isNamespaced,
-        hooks(req, res) {
-            return {
-                beforeCall({ args, configuration }) {
-                    if (!configuration.normalizerContext) {
-                        const unifiedConfig = configuration?.unified ?? {};
-                        const baseNormalizers = {
-                            ...defaultNormalizers,
-                            ...unifiedConfig.normalizers?.override,
-                        };
-                        const normalizers = mergeNormalizers(baseNormalizers, unifiedConfig.normalizers?.addCustomFields ?? []);
-                        configuration.normalizerContext = createNormalizerContext(normalizers, getAdditionalNormalizerContext, { req, res, config: configuration });
-                    }
-                    return args;
-                },
-            };
-        },
-    };
-}
-/**
- * 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(context) {
-    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(context, overrides) {
-    Object.assign(context.config.normalizerContext, overrides);
-}
-function createNormalizerContext(normalizers, getAdditionalNormalizerContext, { req, res, config }) {
-    const logger = Logger;
-    const normalizerContext = {
-        locale: req.cookies?.[LOCALE_COOKIE] ?? "en",
-        ...getAdditionalNormalizerContext({ req, res, config }),
-        logger,
-    };
-    normalizerContext.normalizers = toContextualizedNormalizers(normalizers, () => normalizerContext);
-    return normalizerContext;
-}
-export function mergeNormalizers(baseNormalizers, addCustomFields) {
-    const normalizers = { ...baseNormalizers };
-    addCustomFields.forEach((customFieldsNormalizers) => {
-        Object.entries(customFieldsNormalizers).forEach(([name, customFields]) => {
-            const currentNormalizer = normalizers[name];
-            if (normalizers[name] && customFields) {
-                normalizers[name] = (input, context) => mergeDeepRight(currentNormalizer(input, context), {
-                    $custom: customFields(input, context),
-                });
-            }
-        });
-    });
-    return normalizers;
-}

package/dist/composables/defs/extension.mocks.d.ts

@@ -1,30 +0,0 @@
-interface RawMoney {
-    amount: number;
-    formattedAmount: string;
-    decimalPlaces: number;
-}
-interface RawProduct {
-    id: string;
-    name: string;
-}
-type NormalizerContext = any;
-export declare const normalizers: {
-    normalizeMoney: (rawMoney: RawMoney, ctx: NormalizerContext) => {
-        amount: number;
-        currency: any;
-    };
-    normalizeProductCatalogItem: (rawProduct: RawProduct) => {
-        id: string;
-        name: string;
-    };
-};
-export declare const rawMoneyMock: RawMoney;
-export declare const methods: {
-    getSuccess(): Promise<{
-        ok: boolean;
-    }>;
-};
-export declare const getAdditionalNormalizerContext: () => {
-    sku: string;
-};
-export {};

package/dist/composables/defs/extension.mocks.js

@@ -1,23 +0,0 @@
-export const normalizers = {
-    normalizeMoney: (rawMoney, ctx) => ({
-        amount: rawMoney.amount,
-        currency: ctx.currency,
-    }),
-    normalizeProductCatalogItem: (rawProduct) => ({
-        id: rawProduct.id,
-        name: rawProduct.name,
-    }),
-};
-export const rawMoneyMock = {
-    amount: 10,
-    formattedAmount: "10.00",
-    decimalPlaces: 2,
-};
-export const methods = {
-    getSuccess() {
-        return Promise.resolve({ ok: true });
-    },
-};
-export const getAdditionalNormalizerContext = () => ({
-    sku: "123",
-});

package/dist/composables/defs/extension.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/composables/defs/extension.test.js

@@ -1,233 +0,0 @@
-import { defineFeature, loadFeature } from "jest-cucumber";
-import { beforeEach, expect } from "vitest";
-import { unifiedExtensionFactory } from "./extension";
-import { getAdditionalNormalizerContext, methods, normalizers, rawMoneyMock, } from "./extension.mocks";
-const feature = loadFeature("./extension.feature", {
-    loadRelativePath: true,
-});
-defineFeature(feature, (test) => {
-    let overrideNormalizers;
-    let addCustomFields;
-    let overrideApiMethods;
-    const createUnifiedExtension = unifiedExtensionFactory({
-        normalizers,
-        extendApiMethods: methods,
-        getAdditionalNormalizerContext,
-    });
-    let extension;
-    beforeEach(() => {
-        overrideNormalizers = {};
-        addCustomFields = [{}];
-        overrideApiMethods = {};
-    });
-    function whenTheExtensionIsCreated(when) {
-        when("extension is created", () => {
-            extension = createUnifiedExtension({
-                normalizers: {
-                    override: overrideNormalizers,
-                    addCustomFields,
-                },
-                methods: {
-                    override: overrideApiMethods,
-                },
-                config: {},
-            });
-        });
-    }
-    test("Overriding normalizer", ({ given, when, and, then }) => {
-        let result;
-        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;
-        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;
-        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;
-        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;
-        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/dist/composables/defs/index.d.ts

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

package/dist/composables/defs/index.js

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

package/dist/composables/defs/types.d.ts

@@ -1,81 +0,0 @@
-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";
-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>;
-}
-export {};

package/dist/composables/defs/types.js

@@ -1 +0,0 @@
-export {};

package/dist/composables/domain/product.d.ts

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

package/dist/composables/domain/product.js

@@ -1 +0,0 @@
-export {};

package/dist/composables/helpers/contextualizedNormalizers.d.ts

@@ -1,5 +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 declare function toContextualizedNormalizers<TNormalizers extends NormalizersConstraint, TNormalizerContext extends Record<string, any>>(normalizers: TNormalizers, getContext: () => TNormalizerContext): ContextualizedNormalizers<TNormalizers>;

package/dist/composables/helpers/contextualizedNormalizers.js

@@ -1,6 +0,0 @@
-export function toContextualizedNormalizers(normalizers, getContext) {
-    return Object.keys(normalizers).reduce((acc, key) => {
-        acc[key] = (input) => normalizers[key](getContext(), input);
-        return { ...acc };
-    }, {});
-}

package/dist/composables/helpers/contextualizedNormalizers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/composables/helpers/contextualizedNormalizers.test.js

@@ -1,62 +0,0 @@
-import { defineFeature, loadFeature } from "jest-cucumber";
-import { toContextualizedNormalizers } from "./contextualizedNormalizers";
-import { beforeEach, expect, vi } from "vitest";
-const feature = loadFeature("./contextualizedNormalizers.feature", { loadRelativePath: true });
-defineFeature(feature, (test) => {
-    let testNormalizers;
-    let output;
-    let context;
-    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/dist/composables/helpers/index.d.ts

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

package/dist/composables/helpers/index.js

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