@meeovi/layer-commerce 1.0.3 → 1.0.5

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

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

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

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

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

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

package/dist/composables/defs/index.js

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

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

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

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

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

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

package/dist/composables/domain/product.js

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

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

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

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

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

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

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

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

package/dist/composables/helpers/index.js

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

package/dist/composables/index.d.ts

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

package/dist/composables/index.js

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

package/dist/composables/methods/auth.d.ts

@@ -0,0 +1,62 @@
+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;
+};
+export type RegisterCustomer = (args: Simplify<RegisterCustomerArgs>) => Promise<{
+    customer: SfCustomer;
+}>;
+export interface LoginCustomerExtendedArgs {
+}
+export interface LoginCustomerCustomArgs {
+}
+export type LoginCustomerArgs = {
+    email: string;
+    password: string;
+};
+export type LoginCustomer = (args: Simplify<LoginCustomerArgs>) => Promise<{
+    customer: SfCustomer;
+}>;
+export interface GetCustomerExtendedArgs {
+}
+export interface GetCustomerCustomArgs {
+}
+export type GetCustomerArgs = {};
+export type GetCustomer = (args?: Simplify<GetCustomerArgs>) => Promise<{
+    customer: Maybe<SfCustomer>;
+}>;
+export interface LogoutCustomerExtendedArgs {
+}
+export interface LogoutCustomerCustomArgs {
+}
+export type LogoutCustomerArgs = {};
+export type LogoutCustomer = (args?: Simplify<LogoutCustomerArgs>) => Promise<void>;
+export interface UpdateCustomerExtendedArgs {
+}
+export interface UpdateCustomerCustomArgs {
+}
+export type UpdateCustomerArgs = {
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+};
+export type UpdateCustomer = (args: Simplify<UpdateCustomerArgs>) => Promise<{
+    customer: SfCustomer;
+}>;
+export interface ChangeCustomerPasswordExtendedArgs {
+}
+export interface ChangeCustomerPasswordCustomArgs {
+}
+export type ChangeCustomerPasswordArgs = {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+};
+export type ChangeCustomerPassword = (args: Simplify<ChangeCustomerPasswordArgs>) => Promise<void>;

package/dist/composables/methods/auth.js

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

package/dist/composables/methods/cart.d.ts

@@ -0,0 +1,101 @@
+import type { Simplify } from "type-fest";
+import type { Maybe, SfCart } from "../models";
+export interface GetCartExtendedArgs {
+}
+export interface GetCartCustomArgs {
+}
+export type GetCartArgs = {
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+export interface AddCartLineItemExtendedArgs {
+}
+export interface AddCartLineItemCustomArgs {
+}
+export type AddCartLineItemArgs = {
+    /**
+     * Product unique identifier - for commercetools it's a SKU, for sap it's a product code
+     */
+    productId: string;
+    sku: Maybe<string>;
+    /**
+     * Quantity of product to add to cart
+     * @default 1
+     */
+    quantity?: number;
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+export interface UpdateCartLineItemExtendedArgs {
+}
+export interface UpdateCartLineItemCustomArgs {
+}
+export type UpdateCartLineItemArgs = {
+    lineItemId: string;
+    quantity: number;
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+export interface RemoveCartLineItemExtendedArgs {
+}
+export interface RemoveCartLineItemCustomArgs {
+}
+export type RemoveCartLineItemArgs = {
+    lineItemId: string;
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+export interface ApplyCouponToCartExtendedArgs {
+}
+export interface ApplyCouponToCartCustomArgs {
+}
+export type ApplyCouponToCartArgs = {
+    couponCode: string;
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+export interface RemoveCouponFromCartExtendedArgs {
+}
+export interface RemoveCouponFromCartCustomArgs {
+}
+export type RemoveCouponFromCartArgs = {
+    /**
+     * Don't confuse it with coupon code. It can be retrieved from cart.appliedCoupons
+     */
+    couponId: string;
+    /**
+     * Unique identifier of cart
+     */
+    cartId?: string;
+};
+/**
+ * Get all information about customer's cart
+ */
+export type GetCart = (args?: Simplify<GetCartArgs>) => Promise<SfCart>;
+/**
+ * Add product to cart
+ */
+export type AddCartLineItem = (args: Simplify<AddCartLineItemArgs>) => Promise<SfCart>;
+/**
+ * Update product quantity in cart
+ */
+export type UpdateCartLineItem = (args: Simplify<UpdateCartLineItemArgs>) => Promise<SfCart>;
+/**
+ * Remove product from cart
+ */
+export type RemoveCartLineItem = (args: Simplify<RemoveCartLineItemArgs>) => Promise<SfCart>;
+/**
+ * Apply a coupon to cart to get a discount
+ */
+export type ApplyCouponToCart = (args: Simplify<ApplyCouponToCartArgs>) => Promise<SfCart>;
+export type RemoveCouponFromCart = (args: Simplify<RemoveCouponFromCartArgs>) => Promise<SfCart>;

package/dist/composables/methods/cart.js

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