@plasmicpkgs/commerce 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1 @@
+Plasmic registration calls for commerce components

package/dist/api/endpoints/cart.d.ts

@@ -0,0 +1,4 @@
+import type { CartSchema } from '../../types/cart';
+import type { GetAPISchema } from '..';
+declare const cartEndpoint: GetAPISchema<any, CartSchema<any>>['endpoint']['handler'];
+export default cartEndpoint;

package/dist/api/endpoints/catalog/products.d.ts

@@ -0,0 +1,4 @@
+import type { ProductsSchema } from '../../../types/product';
+import type { GetAPISchema } from '../..';
+declare const productsEndpoint: GetAPISchema<any, ProductsSchema>['endpoint']['handler'];
+export default productsEndpoint;

package/dist/api/index.d.ts

@@ -0,0 +1,75 @@
+import type { NextApiHandler } from 'next';
+import type { FetchOptions, Response } from '@vercel/fetch';
+import type { APIEndpoint, APIHandler } from './utils/types';
+import type { CartSchema } from '../types/cart';
+import type { CustomerSchema } from '../types/customer';
+import type { LoginSchema } from '../types/login';
+import type { LogoutSchema } from '../types/logout';
+import type { SignupSchema } from '../types/signup';
+import type { ProductsSchema } from '../types/product';
+import type { WishlistSchema } from '../types/wishlist';
+import type { CheckoutSchema } from '../types/checkout';
+import type { CustomerCardSchema } from '../types/customer/card';
+import type { CustomerAddressSchema } from '../types/customer/address';
+import { AllOperations, APIOperations } from './operations';
+export declare type APISchemas = CartSchema | CustomerSchema | LoginSchema | LogoutSchema | SignupSchema | ProductsSchema | WishlistSchema | CheckoutSchema | CustomerCardSchema | CustomerAddressSchema;
+export declare type GetAPISchema<C extends CommerceAPI<any>, S extends APISchemas = APISchemas> = {
+    schema: S;
+    endpoint: EndpointContext<C, S['endpoint']>;
+};
+export declare type EndpointContext<C extends CommerceAPI, E extends EndpointSchemaBase> = {
+    handler: Endpoint<C, E>;
+    handlers: EndpointHandlers<C, E>;
+};
+export declare type EndpointSchemaBase = {
+    options: {};
+    handlers: {
+        [k: string]: {
+            data?: any;
+            body?: any;
+        };
+    };
+};
+export declare type Endpoint<C extends CommerceAPI, E extends EndpointSchemaBase> = APIEndpoint<C, EndpointHandlers<C, E>, any, E['options']>;
+export declare type EndpointHandlers<C extends CommerceAPI, E extends EndpointSchemaBase> = {
+    [H in keyof E['handlers']]: APIHandler<C, EndpointHandlers<C, E>, NonNullable<E['handlers'][H]>['data'], NonNullable<E['handlers'][H]>['body'], E['options']>;
+};
+export declare type APIProvider = {
+    config: CommerceAPIConfig;
+    operations: APIOperations<any>;
+};
+export declare type CommerceAPI<P extends APIProvider = APIProvider> = CommerceAPICore<P> & AllOperations<P>;
+export declare class CommerceAPICore<P extends APIProvider = APIProvider> {
+    readonly provider: P;
+    constructor(provider: P);
+    getConfig(userConfig?: Partial<P['config']>): P['config'];
+    setConfig(newConfig: Partial<P['config']>): void;
+}
+export declare function getCommerceApi<P extends APIProvider>(customProvider: P): CommerceAPI<P>;
+export declare function getEndpoint<P extends APIProvider, T extends GetAPISchema<any, any>>(commerce: CommerceAPI<P>, context: T['endpoint'] & {
+    config?: P['config'];
+    options?: T['schema']['endpoint']['options'];
+}): NextApiHandler;
+export declare const createEndpoint: <API extends GetAPISchema<any, any>>(endpoint: API["endpoint"]) => <P extends APIProvider>(commerce: CommerceAPI<P>, context?: (Partial<API["endpoint"]> & {
+    config?: P["config"] | undefined;
+    options?: API["schema"]["endpoint"]["options"] | undefined;
+}) | undefined) => NextApiHandler;
+export interface CommerceAPIConfig {
+    locale?: string;
+    locales?: string[];
+    commerceUrl: string;
+    apiToken: string;
+    cartCookie: string;
+    cartCookieMaxAge: number;
+    customerCookie: string;
+    fetch<Data = any, Variables = any>(query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions): Promise<GraphQLFetcherResult<Data>>;
+}
+export declare type GraphQLFetcher<Data extends GraphQLFetcherResult = GraphQLFetcherResult, Variables = any> = (query: string, queryData?: CommerceAPIFetchOptions<Variables>, fetchOptions?: FetchOptions) => Promise<Data>;
+export interface GraphQLFetcherResult<Data = any> {
+    data: Data;
+    res: Response;
+}
+export interface CommerceAPIFetchOptions<Variables> {
+    variables?: Variables;
+    preview?: boolean;
+}

package/dist/api/operations.d.ts

@@ -0,0 +1,130 @@
+/// <reference types="node" />
+import type { ServerResponse } from 'http';
+import type { LoginOperation } from '../types/login';
+import type { GetAllPagesOperation, GetPageOperation } from '../types/page';
+import type { GetSiteInfoOperation } from '../types/site';
+import type { GetCustomerWishlistOperation } from '../types/wishlist';
+import type { GetAllProductPathsOperation, GetAllProductsOperation, GetProductOperation } from '../types/product';
+import type { APIProvider, CommerceAPI } from '.';
+declare const noop: () => never;
+export declare const OPERATIONS: readonly ["login", "getAllPages", "getPage", "getSiteInfo", "getCustomerWishlist", "getAllProductPaths", "getAllProducts", "getProduct"];
+export declare const defaultOperations: {
+    login: () => never;
+    getAllPages: () => never;
+    getPage: () => never;
+    getSiteInfo: () => never;
+    getCustomerWishlist: () => never;
+    getAllProductPaths: () => never;
+    getAllProducts: () => never;
+    getProduct: () => never;
+};
+export declare type AllowedOperations = typeof OPERATIONS[number];
+export declare type Operations<P extends APIProvider> = {
+    login: {
+        <T extends LoginOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            res: ServerResponse;
+        }): Promise<T['data']>;
+        <T extends LoginOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            res: ServerResponse;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllPages: {
+        <T extends GetAllPagesOperation>(opts?: {
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetAllPagesOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getPage: {
+        <T extends GetPageOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetPageOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getSiteInfo: {
+        <T extends GetSiteInfoOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetSiteInfoOperation>(opts: {
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getCustomerWishlist: {
+        <T extends GetCustomerWishlistOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            includeProducts?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetCustomerWishlistOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            includeProducts?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllProductPaths: {
+        <T extends GetAllProductPathsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+        }): Promise<T['data']>;
+        <T extends GetAllProductPathsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getAllProducts: {
+        <T extends GetAllProductsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetAllProductsOperation>(opts: {
+            variables?: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+    getProduct: {
+        <T extends GetProductOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        }): Promise<T['data']>;
+        <T extends GetProductOperation>(opts: {
+            variables: T['variables'];
+            config?: P['config'];
+            preview?: boolean;
+        } & OperationOptions): Promise<T['data']>;
+    };
+};
+export declare type APIOperations<P extends APIProvider> = {
+    [K in keyof Operations<P>]?: (ctx: OperationContext<P>) => Operations<P>[K];
+};
+export declare type AllOperations<P extends APIProvider> = {
+    [K in keyof APIOperations<P>]-?: P['operations'][K] extends (...args: any) => any ? ReturnType<P['operations'][K]> : typeof noop;
+};
+export declare type OperationContext<P extends APIProvider> = {
+    commerce: CommerceAPI<P>;
+};
+export declare type OperationOptions = {
+    query: string;
+    url?: never;
+} | {
+    query?: never;
+    url: string;
+};
+export {};

package/dist/api/utils/errors.d.ts

@@ -0,0 +1,10 @@
+import type { Response } from '@vercel/fetch';
+export declare class CommerceAPIError extends Error {
+    status: number;
+    res: Response;
+    data: any;
+    constructor(msg: string, res: Response, data?: any);
+}
+export declare class CommerceNetworkError extends Error {
+    constructor(msg: string);
+}

package/dist/api/utils/is-allowed-method.d.ts

@@ -0,0 +1,3 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+export declare type HTTP_METHODS = 'OPTIONS' | 'GET' | 'POST' | 'PUT' | 'DELETE';
+export default function isAllowedMethod(req: NextApiRequest, res: NextApiResponse, allowedMethods: HTTP_METHODS[]): boolean;

package/dist/api/utils/is-allowed-operation.d.ts

@@ -0,0 +1,6 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { HTTP_METHODS } from './is-allowed-method';
+import { APIHandler } from './types';
+export default function isAllowedOperation(req: NextApiRequest, res: NextApiResponse, allowedOperations: {
+    [k in HTTP_METHODS]?: APIHandler<any, any>;
+}): boolean;

package/dist/api/utils/types.d.ts

@@ -0,0 +1,34 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import type { CommerceAPI } from '..';
+export declare type ErrorData = {
+    message: string;
+    code?: string;
+};
+export declare type APIResponse<Data = any> = {
+    data: Data;
+    errors?: ErrorData[];
+} | (Data extends null ? {
+    data: null;
+    errors?: ErrorData[];
+} : {
+    data: null;
+    errors: ErrorData[];
+});
+export declare type APIHandlerContext<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = {
+    req: NextApiRequest;
+    res: NextApiResponse<APIResponse<Data>>;
+    commerce: C;
+    config: C['provider']['config'];
+    handlers: H;
+    /**
+     * Custom configs that may be used by a particular handler
+     */
+    options: Options;
+};
+export declare type APIHandler<C extends CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Body = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options> & {
+    body: Body;
+}) => void | Promise<void>;
+export declare type APIHandlers<C extends CommerceAPI> = {
+    [k: string]: APIHandler<C, any, any, any, any>;
+};
+export declare type APIEndpoint<C extends CommerceAPI = CommerceAPI, H extends APIHandlers<C> = {}, Data = any, Options extends {} = {}> = (context: APIHandlerContext<C, H, Data, Options>) => void | Promise<void>;

package/dist/cart/use-add-item.d.ts

@@ -1,6 +1,5 @@
-import type { HookFetcherFn, MutationHook } from '../utils/types';
-import type { AddItemHook } from '../types/cart';
-export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
-export declare const fetcher: HookFetcherFn<AddItemHook>;
-declare const useAddItem: UseAddItem;
-export default useAddItem;
+import type { MutationHook } from '../utils/types';
+import type { AddItemHook } from '../types/cart';
+export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
+declare const useAddItem: UseAddItem;
+export default useAddItem;

package/dist/cart/use-cart.d.ts

@@ -1,6 +1,5 @@
-import type { SWRHook, HookFetcherFn } from '../utils/types';
-import type { GetCartHook } from '../types/cart';
-export declare type UseCart<H extends SWRHook<GetCartHook<any>> = SWRHook<GetCartHook>> = ReturnType<H['useHook']>;
-export declare const fetcher: HookFetcherFn<GetCartHook>;
-declare const useCart: UseCart;
-export default useCart;
+import type { SWRHook } from '../utils/types';
+import type { GetCartHook } from '../types/cart';
+export declare type UseCart<H extends SWRHook<GetCartHook<any>> = SWRHook<GetCartHook>> = ReturnType<H['useHook']>;
+declare const useCart: UseCart;
+export default useCart;

package/dist/cart/use-remove-item.d.ts

@@ -1,6 +1,5 @@
-import type { HookFetcherFn, MutationHook } from '../utils/types';
-import type { RemoveItemHook } from '../types/cart';
-export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
-export declare const fetcher: HookFetcherFn<RemoveItemHook>;
-declare const useRemoveItem: UseRemoveItem;
-export default useRemoveItem;
+import type { MutationHook } from '../utils/types';
+import type { RemoveItemHook } from '../types/cart';
+export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
+declare const useRemoveItem: UseRemoveItem;
+export default useRemoveItem;

package/dist/cart/use-update-item.d.ts

@@ -1,6 +1,5 @@
-import type { HookFetcherFn, MutationHook } from '../utils/types';
-import type { UpdateItemHook } from '../types/cart';
-export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
-export declare const fetcher: HookFetcherFn<UpdateItemHook>;
-declare const useUpdateItem: UseUpdateItem;
-export default useUpdateItem;
+import type { MutationHook } from '../utils/types';
+import type { UpdateItemHook } from '../types/cart';
+export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
+declare const useUpdateItem: UseUpdateItem;
+export default useUpdateItem;