@wix/sdk 1.5.9 → 1.6.1

package/cjs/build/auth/oauth2/types.d.ts

@@ -0,0 +1,121 @@
+import { authentication } from '@wix/identity';
+import { AuthenticationStrategy } from '@wix/sdk-types';
+export interface Tokens {
+    accessToken: AccessToken;
+    refreshToken: RefreshToken;
+}
+export interface Token {
+    value: string;
+}
+export interface AccessToken extends Token {
+    expiresAt: number;
+}
+export interface RefreshToken extends Token {
+    role: TokenRole;
+}
+export interface OauthData extends OauthPKCE {
+    originalUri: string;
+    redirectUri: string;
+}
+export interface OauthPKCE {
+    codeVerifier: string;
+    codeChallenge: string;
+    state: string;
+}
+export interface RegisterParams extends LoginParams {
+    profile?: authentication.IdentityProfile;
+}
+export interface LoginParams {
+    email: string;
+    password: string;
+    captchaTokens?: {
+        invisibleRecaptchaToken?: string;
+        recaptchaToken?: string;
+    };
+}
+export interface IOAuthStrategy extends AuthenticationStrategy {
+    generateVisitorTokens(tokens?: {
+        refreshToken?: RefreshToken;
+        accessToken?: AccessToken;
+    }): Promise<Tokens>;
+    renewToken: (refreshToken: RefreshToken) => Promise<Tokens>;
+    setTokens: (tokens: Tokens) => void;
+    getTokens: () => Tokens;
+    generateOAuthData: (redirectUri: string, originalUri?: string) => OauthData;
+    getAuthUrl: (oauthData: OauthData, opts?: {
+        prompt?: 'login' | 'none';
+        responseMode?: 'fragment' | 'web_message' | 'query';
+    }) => Promise<{
+        authUrl: string;
+    }>;
+    getMemberTokens: (code: string, state: string, oauthData: OauthData) => Promise<Tokens>;
+    logout: (originalUrl: string) => Promise<{
+        logoutUrl: string;
+    }>;
+    parseFromUrl: (url?: string, responseMode?: 'query' | 'fragment') => {
+        code: string;
+        state: string;
+        error?: string;
+        errorDescription?: string;
+    };
+    register: (params: RegisterParams) => Promise<StateMachine>;
+    login: (params: LoginParams) => Promise<StateMachine>;
+    processVerification<T extends ProcessableState>(nextInputs: CalculateNextState<T>, state?: StateMachine): Promise<StateMachine>;
+    getMemberTokensForDirectLogin: (sessionToken: string) => Promise<Tokens>;
+    sendPasswordResetEmail: (email: string, redirectUri: string) => Promise<void>;
+    captchaInvisibleSiteKey: string;
+    captchaVisibleSiteKey: string;
+    loggedIn: () => boolean;
+}
+export declare enum LoginState {
+    SUCCESS = "SUCCESS",
+    INITIAL = "INITIAL",
+    FAILURE = "FAILURE",
+    EMAIL_VERIFICATION_REQUIRED = "EMAIL_VERIFICATION_REQUIRED",
+    OWNER_APPROVAL_REQUIRED = "OWNER_APPROVAL_REQUIRED",
+    USER_CAPTCHA_REQUIRED = "USER_CAPTCHA_REQUIRED",
+    SILENT_CAPTCHA_REQUIRED = "SILENT_CAPTCHA_REQUIRED"
+}
+interface LoginResults<LK extends LoginState> {
+    loginState: LK;
+}
+interface SuccessState extends LoginResults<LoginState.SUCCESS> {
+    data: {
+        sessionToken: string;
+    };
+}
+interface InitialState extends LoginResults<LoginState.INITIAL> {
+}
+interface ErrorState extends LoginResults<LoginState.FAILURE> {
+    errorCode?: 'invalidEmail' | 'invalidPassword' | 'resetPassword' | 'missingCaptchaToken' | 'emailAlreadyExists' | 'invalidCaptchaToken';
+    error: string;
+}
+interface EmailVerificationRequiredState extends LoginResults<LoginState.EMAIL_VERIFICATION_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+interface OwnerApprovalRequiredState extends LoginResults<LoginState.OWNER_APPROVAL_REQUIRED> {
+}
+interface SilentCaptchaRequiredState extends LoginResults<LoginState.SILENT_CAPTCHA_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+interface UserCaptchaRequiredState extends LoginResults<LoginState.USER_CAPTCHA_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+export declare enum TokenRole {
+    NONE = "none",
+    VISITOR = "visitor",
+    MEMBER = "member"
+}
+export type StateMachine = InitialState | SuccessState | ErrorState | EmailVerificationRequiredState | OwnerApprovalRequiredState | SilentCaptchaRequiredState | UserCaptchaRequiredState;
+type VerificationCode = {
+    verificationCode: string;
+};
+export type CalculateNextState<T> = T extends EmailVerificationRequiredState ? VerificationCode : never;
+export type ProcessableState = EmailVerificationRequiredState;
+export {};

package/cjs/build/auth/oauth2/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenRole = exports.LoginState = void 0;
+var LoginState;
+(function (LoginState) {
+    LoginState["SUCCESS"] = "SUCCESS";
+    LoginState["INITIAL"] = "INITIAL";
+    LoginState["FAILURE"] = "FAILURE";
+    LoginState["EMAIL_VERIFICATION_REQUIRED"] = "EMAIL_VERIFICATION_REQUIRED";
+    LoginState["OWNER_APPROVAL_REQUIRED"] = "OWNER_APPROVAL_REQUIRED";
+    LoginState["USER_CAPTCHA_REQUIRED"] = "USER_CAPTCHA_REQUIRED";
+    LoginState["SILENT_CAPTCHA_REQUIRED"] = "SILENT_CAPTCHA_REQUIRED";
+})(LoginState || (exports.LoginState = LoginState = {}));
+var TokenRole;
+(function (TokenRole) {
+    TokenRole["NONE"] = "none";
+    TokenRole["VISITOR"] = "visitor";
+    TokenRole["MEMBER"] = "member";
+})(TokenRole || (exports.TokenRole = TokenRole = {}));

package/cjs/build/bi/biHeaderGenerator.d.ts

@@ -0,0 +1,12 @@
+import { APIMetadata } from '@wix/sdk-types';
+import { PublicMetadata } from '../common.js';
+export declare const WixBIHeaderName = "x-wix-bi-gateway";
+export type WixBIHeaderValues = {
+    ['environment']: 'js-sdk';
+    ['package-name']?: string;
+    ['method-fqn']?: string;
+    ['entity']?: string;
+};
+export declare function biHeaderGenerator(apiMetadata: APIMetadata, publicMetadata?: PublicMetadata): {
+    [WixBIHeaderName]: string;
+};

package/cjs/build/bi/biHeaderGenerator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.biHeaderGenerator = exports.WixBIHeaderName = void 0;
+exports.WixBIHeaderName = 'x-wix-bi-gateway';
+function biHeaderGenerator(apiMetadata, publicMetadata) {
+    return {
+        [exports.WixBIHeaderName]: objectToKeyValue({
+            environment: 'js-sdk',
+            'package-name': apiMetadata.packageName ?? publicMetadata?.PACKAGE_NAME,
+            'method-fqn': apiMetadata.methodFqn,
+            entity: apiMetadata.entityFqdn,
+        }),
+    };
+}
+exports.biHeaderGenerator = biHeaderGenerator;
+function objectToKeyValue(input) {
+    return Object.entries(input)
+        .filter(([_, value]) => Boolean(value))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(',');
+}

package/cjs/build/common.d.ts

@@ -0,0 +1,7 @@
+export declare const PUBLIC_METADATA_KEY = "__metadata";
+export type PublicMetadata = {
+    PACKAGE_NAME?: string;
+};
+export declare const API_URL = "www.wixapis.com";
+export declare const READ_ONLY_API_URL = "readonly.wixapis.com";
+export declare const FORCE_WRITE_API_URLS: string[];

package/cjs/build/common.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORCE_WRITE_API_URLS = exports.READ_ONLY_API_URL = exports.API_URL = exports.PUBLIC_METADATA_KEY = void 0;
+exports.PUBLIC_METADATA_KEY = '__metadata';
+exports.API_URL = 'www.wixapis.com';
+exports.READ_ONLY_API_URL = 'readonly.wixapis.com';
+exports.FORCE_WRITE_API_URLS = ['/ecom/v1/carts/current'];

package/cjs/build/fetch-error.d.ts

@@ -0,0 +1,9 @@
+export declare class FetchErrorResponse extends Error {
+    readonly message: string;
+    readonly response: Response;
+    constructor(message: string, response: Response);
+    details(): Promise<{
+        details: any;
+        message: string;
+    }>;
+}

package/cjs/build/fetch-error.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchErrorResponse = void 0;
+class FetchErrorResponse extends Error {
+    message;
+    response;
+    constructor(message, response) {
+        super(message);
+        this.message = message;
+        this.response = response;
+    }
+    async details() {
+        const dataError = await this.response.json();
+        return errorBuilder(this.response.status, dataError?.message, dataError?.details, {
+            requestId: this.response.headers.get('X-Wix-Request-Id'),
+            details: dataError,
+        });
+    }
+}
+exports.FetchErrorResponse = FetchErrorResponse;
+const errorBuilder = (code, description, details, data) => {
+    return {
+        details: {
+            ...(!details?.validationError && {
+                applicationError: {
+                    description,
+                    code,
+                    data,
+                },
+            }),
+            ...details,
+        },
+        message: description,
+    };
+};

package/cjs/build/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const getDefaultContentHeader: (options: RequestInit | undefined) => {
+    'Content-Type'?: string;
+};
+export declare const isObject: (val: any) => val is Object;

package/cjs/build/helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = exports.getDefaultContentHeader = void 0;
+// we follow a simplified version of the axios convention
+// https://github.com/axios/axios/blob/649d739288c8e2c55829ac60e2345a0f3439c730/lib/defaults/index.js#L65
+const getDefaultContentHeader = (options) => {
+    if (options?.method &&
+        ['post', 'put', 'patch'].includes(options.method.toLocaleLowerCase()) &&
+        options.body) {
+        return { 'Content-Type': 'application/json' };
+    }
+    return {};
+};
+exports.getDefaultContentHeader = getDefaultContentHeader;
+const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val);
+exports.isObject = isObject;

package/cjs/build/host-modules.d.ts

@@ -0,0 +1,3 @@
+import { Host, HostModule } from '@wix/sdk-types';
+export declare const isHostModule: (val: any) => val is HostModule<unknown, Host>;
+export declare function buildHostModule(val: HostModule<unknown, Host>, host: Host): unknown;

package/cjs/build/host-modules.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHostModule = exports.isHostModule = void 0;
+const helpers_js_1 = require("./helpers.js");
+const isHostModule = (val) => (0, helpers_js_1.isObject)(val) && val.__type === 'host';
+exports.isHostModule = isHostModule;
+function buildHostModule(val, host) {
+    return val.create(host);
+}
+exports.buildHostModule = buildHostModule;

package/cjs/build/iframeUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function addListener(eventTarget: any, name: string, fn: Function): void;
+export declare function removeListener(eventTarget: any, name: string, fn: Function): void;
+export declare function loadFrame(src: string): HTMLIFrameElement;
+export declare function addPostMessageListener(state: string): Promise<unknown>;

package/cjs/build/iframeUtils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPostMessageListener = exports.loadFrame = exports.removeListener = exports.addListener = void 0;
+function addListener(eventTarget, name, fn) {
+    if (eventTarget.addEventListener) {
+        eventTarget.addEventListener(name, fn);
+    }
+    else {
+        eventTarget.attachEvent('on' + name, fn);
+    }
+}
+exports.addListener = addListener;
+function removeListener(eventTarget, name, fn) {
+    if (eventTarget.removeEventListener) {
+        eventTarget.removeEventListener(name, fn);
+    }
+    else {
+        eventTarget.detachEvent('on' + name, fn);
+    }
+}
+exports.removeListener = removeListener;
+function loadFrame(src) {
+    const iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    iframe.src = src;
+    return document.body.appendChild(iframe);
+}
+exports.loadFrame = loadFrame;
+function addPostMessageListener(state) {
+    let responseHandler;
+    let timeoutId;
+    const msgReceivedOrTimeout = new Promise((resolve, reject) => {
+        responseHandler = (e) => {
+            if (!e.data || e.data.state !== state) {
+                // A message not meant for us
+                return;
+            }
+            resolve(e.data);
+        };
+        addListener(window, 'message', responseHandler);
+        timeoutId = setTimeout(() => {
+            reject(new Error('OAuth flow timed out'));
+        }, 120000);
+    });
+    return msgReceivedOrTimeout.finally(() => {
+        clearTimeout(timeoutId);
+        removeListener(window, 'message', responseHandler);
+    });
+}
+exports.addPostMessageListener = addPostMessageListener;

package/cjs/build/index.d.ts

@@ -0,0 +1,9 @@
+export * from './wixClient.js';
+export * from './wixMedia.js';
+export * from './auth/oauth2/OAuthStrategy.js';
+export * from './auth/oauth2/types.js';
+export * from './auth/ApiKeyAuthStrategy.js';
+export * from './auth/WixAppOAuthStrategy.js';
+export * from '@wix/sdk-types';
+export { getDefaultDomain } from './rest-modules.js';
+export { API_URL } from './common.js';

package/cjs/build/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_URL = exports.getDefaultDomain = void 0;
+__exportStar(require("./wixClient.js"), exports);
+__exportStar(require("./wixMedia.js"), exports);
+__exportStar(require("./auth/oauth2/OAuthStrategy.js"), exports);
+__exportStar(require("./auth/oauth2/types.js"), exports);
+__exportStar(require("./auth/ApiKeyAuthStrategy.js"), exports);
+__exportStar(require("./auth/WixAppOAuthStrategy.js"), exports);
+__exportStar(require("@wix/sdk-types"), exports);
+var rest_modules_js_1 = require("./rest-modules.js");
+Object.defineProperty(exports, "getDefaultDomain", { enumerable: true, get: function () { return rest_modules_js_1.getDefaultDomain; } });
+var common_js_1 = require("./common.js");
+Object.defineProperty(exports, "API_URL", { enumerable: true, get: function () { return common_js_1.API_URL; } });

package/cjs/build/rest-modules.d.ts

@@ -0,0 +1,7 @@
+import { PublicMetadata } from './common.js';
+import { BuildRESTFunction, RESTFunctionDescriptor } from '@wix/sdk-types';
+export type RESTModuleOptions = {
+    HTTPHost?: string;
+};
+export declare const getDefaultDomain: (method: string, url: string) => "www.wixapis.com" | "readonly.wixapis.com";
+export declare function buildRESTDescriptor<T extends RESTFunctionDescriptor>(origFunc: T, publicMetadata: PublicMetadata, boundFetch: (url: string | URL, init?: RequestInit) => Promise<Response>, options?: RESTModuleOptions): BuildRESTFunction<T>;

package/cjs/build/rest-modules.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRESTDescriptor = exports.getDefaultDomain = void 0;
+const biHeaderGenerator_js_1 = require("./bi/biHeaderGenerator.js");
+const common_js_1 = require("./common.js");
+const getDefaultDomain = (method, url) => method === 'GET' &&
+    !common_js_1.FORCE_WRITE_API_URLS.some((write_url) => url === write_url)
+    ? common_js_1.READ_ONLY_API_URL
+    : common_js_1.API_URL;
+exports.getDefaultDomain = getDefaultDomain;
+function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, options) {
+    return origFunc({
+        request: async (factory) => {
+            const requestOptions = factory({ host: options?.HTTPHost || common_js_1.API_URL });
+            let request = requestOptions;
+            if (request.method === 'GET' &&
+                request.fallback?.length &&
+                request.params.toString().length > 4000) {
+                request = requestOptions.fallback[0];
+            }
+            const domain = options?.HTTPHost ?? (0, exports.getDefaultDomain)(request.method, request.url);
+            let url = `https://${domain}${request.url}`;
+            if (request.params && request.params.toString()) {
+                url += `?${request.params.toString()}`;
+            }
+            try {
+                const biHeader = (0, biHeaderGenerator_js_1.biHeaderGenerator)(requestOptions, publicMetadata);
+                const res = await boundFetch(url, {
+                    method: request.method,
+                    ...(request.data && {
+                        body: JSON.stringify(request.data),
+                    }),
+                    headers: {
+                        ...biHeader,
+                    },
+                });
+                if (res.status !== 200) {
+                    let dataError = null;
+                    try {
+                        dataError = await res.json();
+                    }
+                    catch (e) {
+                        //
+                    }
+                    throw errorBuilder(res.status, dataError?.message, dataError?.details, {
+                        requestId: res.headers.get('X-Wix-Request-Id'),
+                        details: dataError,
+                    });
+                }
+                const data = await res.json();
+                return {
+                    data,
+                    headers: res.headers,
+                    status: res.status,
+                    statusText: res.statusText,
+                };
+            }
+            catch (e) {
+                if (e.message?.includes('fetch is not defined')) {
+                    console.error('Node.js v18+ is required');
+                }
+                throw e;
+            }
+        },
+    });
+}
+exports.buildRESTDescriptor = buildRESTDescriptor;
+const errorBuilder = (code, description, details, data) => {
+    return {
+        response: {
+            data: {
+                details: {
+                    ...(!details?.validationError && {
+                        applicationError: {
+                            description,
+                            code,
+                            data,
+                        },
+                    }),
+                    ...details,
+                },
+                message: description,
+            },
+            status: code,
+        },
+    };
+};

package/cjs/build/tokenHelpers.d.ts

@@ -0,0 +1,4 @@
+import { AccessToken } from './auth/oauth2/types.js';
+export declare function getCurrentDate(): number;
+export declare function isTokenExpired(token: AccessToken): boolean;
+export declare function createAccessToken(accessToken: string, expiresIn: number): AccessToken;

package/cjs/build/tokenHelpers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccessToken = exports.isTokenExpired = exports.getCurrentDate = void 0;
+function getCurrentDate() {
+    return Math.floor(Date.now() / 1000);
+}
+exports.getCurrentDate = getCurrentDate;
+function isTokenExpired(token) {
+    const currentDate = getCurrentDate();
+    return token.expiresAt < currentDate;
+}
+exports.isTokenExpired = isTokenExpired;
+function createAccessToken(accessToken, expiresIn) {
+    const now = getCurrentDate();
+    return { value: accessToken, expiresAt: Number(expiresIn) + now };
+}
+exports.createAccessToken = createAccessToken;

package/cjs/build/wixClient.d.ts

@@ -0,0 +1,70 @@
+import { AuthenticationStrategy, BoundAuthenticationStrategy, BuildRESTFunction, Host, HostModule, HostModuleAPI, RESTFunctionDescriptor } from '@wix/sdk-types';
+import { ConditionalExcept, EmptyObject } from 'type-fest';
+import { AmbassadorFunctionDescriptor, BuildAmbassadorFunction } from './ambassador-modules.js';
+import { PublicMetadata } from './common.js';
+import type { GraphQLFormattedError } from 'graphql';
+type Headers = Record<string, string>;
+/**
+ * This type takes in a descriptors object of a certain Host (including an `unknown` host)
+ * and returns an object with the same structure, but with all descriptors replaced with their API.
+ * Any non-descriptor properties are removed from the returned object, including descriptors that
+ * do not match the given host (as they will not work with the given host).
+ */
+export type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined> = BuildRESTDescriptors<T> & BuildAmbassadorDescriptors<T> & (H extends Host<any> ? BuildHostDescriptors<T> : {});
+type BuildRESTDescriptors<T extends Descriptors> = T extends RESTFunctionDescriptor ? BuildRESTFunction<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildRESTDescriptors<T[Key]> : never;
+}, EmptyObject>;
+type BuildAmbassadorDescriptors<T extends Descriptors> = T extends AmbassadorFunctionDescriptor ? BuildAmbassadorFunction<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildAmbassadorDescriptors<T[Key]> : never;
+}, EmptyObject>;
+type BuildHostDescriptors<T extends Descriptors> = T extends HostModule<any, any> ? HostModuleAPI<T> : ConditionalExcept<{
+    [Key in keyof T]: T[Key] extends Descriptors ? BuildHostDescriptors<T[Key]> : never;
+}, EmptyObject>;
+/**
+ * Descriptors are objects that describe the API of a module, and the module
+ * can either be a REST module or a host module.
+ * This type is recursive, so it can describe nested modules.
+ */
+export type Descriptors = RESTFunctionDescriptor | AmbassadorFunctionDescriptor | HostModule<any, any> | {
+    [key: string]: Descriptors | PublicMetadata | any;
+};
+/**
+ * This type is used in `createClient` to ensure that the given host matches the host of the given descriptors.
+ * If the host does not match, the descriptor is replaced with a host module that will throw an error when used.
+ */
+export type AssertHostMatches<T extends Descriptors, H extends Host<any>> = T extends HostModule<any, infer U> ? H extends undefined ? never : H extends U ? T : HostModule<any, H> : T extends RESTFunctionDescriptor<any> ? T : {
+    [Key in keyof T]: T[Key] extends Descriptors ? AssertHostMatches<T[Key], H> : T[Key];
+};
+type TypedQueryInput<Result = {
+    [key: string]: any;
+}, Variables = {
+    [key: string]: any;
+}> = {
+    /**
+     * Type to support `@graphql-typed-document-node/core`
+     * @internal
+     */
+    __apiType?: (variables: Variables) => Result;
+    /**
+     * Type to support `TypedQueryDocumentNode` from `graphql`
+     * @internal
+     */
+    __ensureTypesOfVariablesAndResultMatching?: (variables: Variables) => Result;
+};
+export type WixClient<H extends Host<any> | undefined = undefined, Z extends AuthenticationStrategy<H> = AuthenticationStrategy<H>, T extends Descriptors = Descriptors> = {
+    setHeaders(headers: Headers): void;
+    auth: Omit<Z, 'getAuthHeaders'> & BoundAuthenticationStrategy;
+    fetch(relativeUrl: string, options: RequestInit): Promise<Response>;
+    use<R extends Descriptors = EmptyObject>(modules: H extends Host<any> ? AssertHostMatches<R, H> : R): BuildDescriptors<R, H>;
+    graphql<Result, Variables>(query: string | ((string | String) & TypedQueryInput<Result, Variables>), variables?: Variables): Promise<{
+        data: Result;
+        errors?: GraphQLFormattedError[];
+    }>;
+} & BuildDescriptors<T, H>;
+export declare function createClient<H extends Host<any> | undefined = undefined, Z extends AuthenticationStrategy<H> = AuthenticationStrategy<H>, T extends Descriptors = EmptyObject>(config: {
+    modules?: H extends Host<any> ? AssertHostMatches<T, H> : T;
+    auth?: Z;
+    headers?: Headers;
+    host?: H;
+}): WixClient<H, Z, T>;
+export {};

package/cjs/build/wixClient.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+const ambassador_modules_js_1 = require("./ambassador-modules.js");
+const common_js_1 = require("./common.js");
+const helpers_js_1 = require("./helpers.js");
+const host_modules_js_1 = require("./host-modules.js");
+const rest_modules_js_1 = require("./rest-modules.js");
+const fetch_error_js_1 = require("./fetch-error.js");
+function createClient(config) {
+    const _headers = config.headers || { Authorization: '' };
+    const authStrategy = config.auth || {
+        getAuthHeaders: () => Promise.resolve({ headers: {} }),
+    };
+    const boundGetAuthHeaders = authStrategy.getAuthHeaders.bind(undefined, config.host);
+    authStrategy.getAuthHeaders = boundGetAuthHeaders;
+    const boundFetch = async (url, options) => {
+        const authHeaders = await boundGetAuthHeaders();
+        const defaultContentTypeHeader = (0, helpers_js_1.getDefaultContentHeader)(options);
+        return fetch(url, {
+            ...options,
+            headers: {
+                ...defaultContentTypeHeader,
+                ..._headers,
+                ...authHeaders?.headers,
+                ...options?.headers,
+            },
+        });
+    };
+    // This is typed as `any` because when trying to properly type it as defined
+    // on the WixClient, typescript starts failing with `Type instantiation is
+    // excessively deep and possibly infinite.`
+    const use = (modules, metadata) => {
+        if ((0, host_modules_js_1.isHostModule)(modules) && config.host) {
+            return (0, host_modules_js_1.buildHostModule)(modules, config.host);
+        }
+        else if (typeof modules === 'function') {
+            const { module, options } = (0, ambassador_modules_js_1.isAmbassadorModule)(modules)
+                ? {
+                    module: (0, ambassador_modules_js_1.toHTTPModule)(modules),
+                    options: (0, ambassador_modules_js_1.ambassadorModuleOptions)(),
+                }
+                : { module: modules, options: undefined };
+            return (0, rest_modules_js_1.buildRESTDescriptor)(module, metadata ?? {}, boundFetch, options);
+        }
+        else if ((0, helpers_js_1.isObject)(modules)) {
+            return Object.fromEntries(Object.entries(modules).map(([key, value]) => {
+                return [key, use(value, modules[common_js_1.PUBLIC_METADATA_KEY])];
+            }));
+        }
+        else {
+            return modules;
+        }
+    };
+    const setHeaders = (headers) => {
+        for (const k in headers) {
+            _headers[k] = headers[k];
+        }
+    };
+    const wrappedModules = config.modules ? use(config.modules) : {};
+    return {
+        ...wrappedModules,
+        auth: authStrategy,
+        setHeaders,
+        use,
+        fetch: (relativeUrl, options) => {
+            const finalUrl = new URL(relativeUrl, `https://${common_js_1.API_URL}`);
+            finalUrl.host = common_js_1.API_URL;
+            finalUrl.protocol = 'https';
+            return boundFetch(finalUrl.toString(), options);
+        },
+        async graphql(query, variables, opts = {
+            apiVersion: 'alpha',
+        }) {
+            const res = await boundFetch(`https://${common_js_1.API_URL}/graphql/${opts.apiVersion}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ query, variables }),
+            });
+            if (res.status !== 200) {
+                throw new fetch_error_js_1.FetchErrorResponse(`GraphQL request failed with status ${res.status}`, res);
+            }
+            const { data, errors } = await res.json();
+            return { data: data ?? {}, errors };
+        },
+    };
+}
+exports.createClient = createClient;