@plasmicpkgs/commerce 0.0.1

package/dist/types/signup.d.ts

@@ -0,0 +1,23 @@
+export declare type SignupBody = {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+};
+export declare type SignupTypes = {
+    body: SignupBody;
+};
+export declare type SignupHook<T extends SignupTypes = SignupTypes> = {
+    data: null;
+    body: T['body'];
+    actionInput: T['body'];
+    fetcherInput: T['body'];
+};
+export declare type SignupSchema<T extends SignupTypes = SignupTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            signup: SignupHook<T>;
+        };
+    };
+};

package/dist/types/site.d.ts

@@ -0,0 +1,17 @@
+export declare type Category = {
+    id: string;
+    name: string;
+    slug: string;
+    path: string;
+};
+export declare type Brand = any;
+export declare type SiteTypes = {
+    category: Category;
+    brand: Brand;
+};
+export declare type GetSiteInfoOperation<T extends SiteTypes = SiteTypes> = {
+    data: {
+        categories: T['category'][];
+        brands: T['brand'][];
+    };
+};

package/dist/types/wishlist.d.ts

@@ -0,0 +1,83 @@
+export declare type Wishlist = any;
+export declare type WishlistItemBody = {
+    variantId: string | number;
+    productId: string;
+};
+export declare type WishlistTypes = {
+    wishlist: Wishlist;
+    itemBody: WishlistItemBody;
+};
+export declare type GetWishlistHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'] | null;
+    body: {
+        includeProducts?: boolean;
+    };
+    input: {
+        includeProducts?: boolean;
+    };
+    fetcherInput: {
+        customerId: string;
+        includeProducts?: boolean;
+    };
+    swrState: {
+        isEmpty: boolean;
+    };
+};
+export declare type AddItemHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'];
+    body: {
+        item: T['itemBody'];
+    };
+    fetcherInput: {
+        item: T['itemBody'];
+    };
+    actionInput: T['itemBody'];
+};
+export declare type RemoveItemHook<T extends WishlistTypes = WishlistTypes> = {
+    data: T['wishlist'] | null;
+    body: {
+        itemId: string;
+    };
+    fetcherInput: {
+        itemId: string;
+    };
+    actionInput: {
+        id: string;
+    };
+    input: {
+        wishlist?: {
+            includeProducts?: boolean;
+        };
+    };
+};
+export declare type WishlistSchema<T extends WishlistTypes = WishlistTypes> = {
+    endpoint: {
+        options: {};
+        handlers: {
+            getWishlist: GetWishlistHook<T> & {
+                data: T['wishlist'] | null;
+                body: {
+                    customerToken?: string;
+                };
+            };
+            addItem: AddItemHook<T> & {
+                body: {
+                    customerToken?: string;
+                };
+            };
+            removeItem: RemoveItemHook<T> & {
+                body: {
+                    customerToken?: string;
+                };
+            };
+        };
+    };
+};
+export declare type GetCustomerWishlistOperation<T extends WishlistTypes = WishlistTypes> = {
+    data: {
+        wishlist?: T['wishlist'];
+    };
+    variables: {
+        customerId: string;
+    };
+};

package/dist/utils/default-fetcher.d.ts

@@ -0,0 +1,4 @@
+import type { HookFetcherFn } from './types';
+export declare const SWRFetcher: HookFetcherFn<any>;
+export declare const mutationFetcher: HookFetcherFn<any>;
+export default SWRFetcher;

package/dist/utils/default-fetcher.js

@@ -0,0 +1,3 @@
+export const SWRFetcher = ({ options, fetch }) => fetch(options);
+export const mutationFetcher = ({ input, options, fetch, }) => fetch({ ...options, body: input });
+export default SWRFetcher;

package/dist/utils/define-property.d.ts

@@ -0,0 +1,21 @@
+declare type InferValue<Prop extends PropertyKey, Desc> = Desc extends {
+    get(): any;
+    value: any;
+} ? never : Desc extends {
+    value: infer T;
+} ? Record<Prop, T> : Desc extends {
+    get(): infer T;
+} ? Record<Prop, T> : never;
+declare type DefineProperty<Prop extends PropertyKey, Desc extends PropertyDescriptor> = Desc extends {
+    writable: any;
+    set(val: any): any;
+} ? never : Desc extends {
+    writable: any;
+    get(): any;
+} ? never : Desc extends {
+    writable: false;
+} ? Readonly<InferValue<Prop, Desc>> : Desc extends {
+    writable: true;
+} ? InferValue<Prop, Desc> : Readonly<InferValue<Prop, Desc>>;
+export default function defineProperty<Obj extends object, Key extends PropertyKey, PDesc extends PropertyDescriptor>(obj: Obj, prop: Key, val: PDesc): asserts obj is Obj & DefineProperty<Key, PDesc>;
+export {};

package/dist/utils/define-property.js

@@ -0,0 +1,4 @@
+// Taken from https://fettblog.eu/typescript-assertion-signatures/
+export default function defineProperty(obj, prop, val) {
+    Object.defineProperty(obj, prop, val);
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,27 @@
+export declare type ErrorData = {
+    message: string;
+    code?: string;
+};
+export declare type ErrorProps = {
+    code?: string;
+} & ({
+    message: string;
+    errors?: never;
+} | {
+    message?: never;
+    errors: ErrorData[];
+});
+export declare class CommerceError extends Error {
+    code?: string;
+    errors: ErrorData[];
+    constructor({ message, code, errors }: ErrorProps);
+}
+export declare class ValidationError extends CommerceError {
+    constructor(options: ErrorProps);
+}
+export declare class FetcherError extends CommerceError {
+    status: number;
+    constructor(options: {
+        status: number;
+    } & ErrorProps);
+}

package/dist/utils/errors.js

@@ -0,0 +1,24 @@
+export class CommerceError extends Error {
+    constructor({ message, code, errors }) {
+        const error = message
+            ? { message, ...(code ? { code } : {}) }
+            : errors[0];
+        super(error.message);
+        this.errors = message ? [error] : errors;
+        if (error.code)
+            this.code = error.code;
+    }
+}
+// Used for errors that come from a bad implementation of the hooks
+export class ValidationError extends CommerceError {
+    constructor(options) {
+        super(options);
+        this.code = 'validation_error';
+    }
+}
+export class FetcherError extends CommerceError {
+    constructor(options) {
+        super(options);
+        this.status = options.status;
+    }
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,94 @@
+import type { SWRConfiguration } from 'swr';
+import type { CommerceError } from './errors';
+import type { ResponseState } from './use-data';
+/**
+ * Returns the properties in T with the properties in type K, overriding properties defined in T
+ */
+export declare type Override<T, K> = Omit<T, keyof K> & K;
+/**
+ * Returns the properties in T with the properties in type K changed from optional to required
+ */
+export declare type PickRequired<T, K extends keyof T> = Omit<T, K> & {
+    [P in K]-?: NonNullable<T[P]>;
+};
+/**
+ * Core fetcher added by CommerceProvider
+ */
+export declare type Fetcher<T = any, B = any> = (options: FetcherOptions<B>) => T | Promise<T>;
+export declare type FetcherOptions<Body = any> = {
+    url?: string;
+    query?: string;
+    method?: string;
+    variables?: any;
+    body?: Body;
+};
+export declare type HookFetcher<Data, Input = null, Result = any> = (options: HookFetcherOptions | null, input: Input, fetch: <T = Result, Body = any>(options: FetcherOptions<Body>) => Promise<T>) => Data | Promise<Data>;
+export declare type HookFetcherFn<H extends HookSchemaBase> = (context: HookFetcherContext<H>) => H['data'] | Promise<H['data']>;
+export declare type HookFetcherContext<H extends HookSchemaBase> = {
+    options: HookFetcherOptions;
+    input: H['fetcherInput'];
+    fetch: <T = H['fetchData'] extends {} | null ? H['fetchData'] : any, B = H['body']>(options: FetcherOptions<B>) => Promise<T>;
+};
+export declare type HookFetcherOptions = {
+    method?: string;
+} & ({
+    query: string;
+    url?: string;
+} | {
+    query?: string;
+    url: string;
+});
+export declare type HookInputValue = string | number | boolean | undefined;
+export declare type HookSWRInput = [string, HookInputValue][];
+export declare type HookFetchInput = {
+    [k: string]: HookInputValue;
+};
+export declare type HookFunction<Input extends {
+    [k: string]: unknown;
+} | undefined, T> = keyof Input extends never ? () => T : Partial<Input> extends Input ? (input?: Input) => T : (input: Input) => T;
+export declare type HookSchemaBase = {
+    data: any;
+    input?: {};
+    fetcherInput?: {};
+    body?: {};
+    fetchData?: any;
+};
+export declare type SWRHookSchemaBase = HookSchemaBase & {
+    swrState?: {};
+    mutations?: Record<string, ReturnType<MutationHook<any>['useHook']>>;
+};
+export declare type MutationSchemaBase = HookSchemaBase & {
+    actionInput?: {};
+};
+/**
+ * Generates a SWR hook handler based on the schema of a hook
+ */
+export declare type SWRHook<H extends SWRHookSchemaBase> = {
+    useHook(context: SWRHookContext<H>): HookFunction<H['input'] & {
+        swrOptions?: SwrOptions<H['data'], H['fetcherInput']>;
+    }, ResponseState<H['data']> & H['swrState'] & H['mutations']>;
+    fetchOptions: HookFetcherOptions;
+    fetcher?: HookFetcherFn<H>;
+};
+export declare type SWRHookContext<H extends SWRHookSchemaBase> = {
+    useData(context?: {
+        input?: HookFetchInput | HookSWRInput;
+        swrOptions?: SwrOptions<H['data'], H['fetcherInput']>;
+    }): ResponseState<H['data']>;
+};
+/**
+ * Generates a mutation hook handler based on the schema of a hook
+ */
+export declare type MutationHook<H extends MutationSchemaBase> = {
+    useHook(context: MutationHookContext<H>): HookFunction<H['input'], HookFunction<H['actionInput'], H['data'] | Promise<H['data']>>>;
+    fetchOptions: HookFetcherOptions;
+    fetcher?: HookFetcherFn<H>;
+};
+export declare type MutationHookContext<H extends MutationSchemaBase> = {
+    fetch: keyof H['fetcherInput'] extends never ? () => H['data'] | Promise<H['data']> : Partial<H['fetcherInput']> extends H['fetcherInput'] ? (context?: {
+        input?: H['fetcherInput'];
+    }) => H['data'] | Promise<H['data']> : (context: {
+        input: H['fetcherInput'];
+    }) => H['data'] | Promise<H['data']>;
+};
+export declare type SwrOptions<Data, Input = null, Result = any> = SWRConfiguration<Data, CommerceError, HookFetcher<Data, Input, Result>>;

package/dist/utils/use-data.d.ts

@@ -0,0 +1,12 @@
+import { SWRResponse } from 'swr';
+import type { HookSWRInput, HookFetchInput, HookFetcherOptions, HookFetcherFn, Fetcher, SwrOptions, SWRHookSchemaBase } from './types';
+import { CommerceError } from './errors';
+export declare type ResponseState<Result> = SWRResponse<Result, CommerceError> & {
+    isLoading: boolean;
+};
+export declare type UseData = <H extends SWRHookSchemaBase>(options: {
+    fetchOptions: HookFetcherOptions;
+    fetcher: HookFetcherFn<H>;
+}, input: HookFetchInput | HookSWRInput, fetcherFn: Fetcher, swrOptions?: SwrOptions<H['data'], H['fetcherInput']>) => ResponseState<H['data']>;
+declare const useData: UseData;
+export default useData;

package/dist/utils/use-data.js

@@ -0,0 +1,43 @@
+import useSWR from 'swr';
+import defineProperty from './define-property';
+import { CommerceError } from './errors';
+const useData = (options, input, fetcherFn, swrOptions) => {
+    const hookInput = Array.isArray(input) ? input : Object.entries(input);
+    const fetcher = async (url, query, method, ...args) => {
+        try {
+            return await options.fetcher({
+                options: { url, query, method },
+                // Transform the input array into an object
+                input: args.reduce((obj, val, i) => {
+                    obj[hookInput[i][0]] = val;
+                    return obj;
+                }, {}),
+                fetch: fetcherFn,
+            });
+        }
+        catch (error) {
+            // SWR will not log errors, but any error that's not an instance
+            // of CommerceError is not welcomed by this hook
+            if (!(error instanceof CommerceError)) {
+                console.error(error);
+            }
+            throw error;
+        }
+    };
+    const response = useSWR(() => {
+        const opts = options.fetchOptions;
+        return opts
+            ? [opts.url, opts.query, opts.method, ...hookInput.map((e) => e[1])]
+            : null;
+    }, fetcher, swrOptions);
+    if (!('isLoading' in response)) {
+        defineProperty(response, 'isLoading', {
+            get() {
+                return response.data === undefined;
+            },
+            enumerable: true,
+        });
+    }
+    return response;
+};
+export default useData;

package/dist/utils/use-hook.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from '..';
+import type { MutationHook, PickRequired, SWRHook } from './types';
+export declare function useFetcher(): import("./types").Fetcher<any, any>;
+export declare function useHook<P extends Provider, H extends MutationHook<any> | SWRHook<any>>(fn: (provider: P) => H): H;
+export declare function useSWRHook<H extends SWRHook<any>>(hook: PickRequired<H, 'fetcher'>): (input?: any) => any;
+export declare function useMutationHook<H extends MutationHook<any>>(hook: PickRequired<H, 'fetcher'>): (input?: any) => (input?: any) => any;

package/dist/utils/use-hook.js

@@ -0,0 +1,37 @@
+import { useCallback } from 'react';
+import { useCommerce } from '..';
+import useData from './use-data';
+export function useFetcher() {
+    const { providerRef, fetcherRef } = useCommerce();
+    return providerRef.current.fetcher ?? fetcherRef.current;
+}
+export function useHook(fn) {
+    console.log("oi?");
+    const x = useCommerce();
+    console.log("test", x);
+    const { providerRef } = useCommerce();
+    console.log("dale", providerRef);
+    const provider = providerRef.current;
+    return fn(provider);
+}
+export function useSWRHook(hook) {
+    const fetcher = useFetcher();
+    return hook.useHook({
+        useData(ctx) {
+            const response = useData(hook, ctx?.input ?? [], fetcher, ctx?.swrOptions);
+            return response;
+        },
+    });
+}
+export function useMutationHook(hook) {
+    const fetcher = useFetcher();
+    return hook.useHook({
+        fetch: useCallback(({ input } = {}) => {
+            return hook.fetcher({
+                input,
+                options: hook.fetchOptions,
+                fetch: fetcher,
+            });
+        }, [fetcher, hook.fetchOptions]),
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@plasmicpkgs/commerce",
+  "version": "0.0.1",
+  "description": "Plasmic components and registration calls for commerce providers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/commerce.esm.js",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": [
+      "./dist/*.js",
+      "./dist/*/index.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsdx build",
+    "start": "tsdx watch",
+    "test": "tsdx test --passWithNoTests",
+    "lint": "tsdx lint",
+    "prepare": "tsc",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^4.11.0",
+    "@types/js-cookie": "^3.0.1",
+    "@types/node": "^14.0.26",
+    "size-limit": "^4.11.0",
+    "tsdx": "^0.14.1",
+    "tslib": "^2.2.0",
+    "typescript": "^3.9.7"
+  },
+  "dependencies": {
+    "antd": "^4.19.1",
+    "js-cookie": "^3.0.1",
+    "swr": "^1.2.2"
+  }
+}