@wix/sdk 1.5.9 → 1.6.1

package/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/build/rest-modules.js

@@ -0,0 +1,82 @@
+import { biHeaderGenerator } from './bi/biHeaderGenerator.js';
+import { API_URL, FORCE_WRITE_API_URLS, READ_ONLY_API_URL, } from './common.js';
+export const getDefaultDomain = (method, url) => method === 'GET' &&
+    !FORCE_WRITE_API_URLS.some((write_url) => url === write_url)
+    ? READ_ONLY_API_URL
+    : API_URL;
+export function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, options) {
+    return origFunc({
+        request: async (factory) => {
+            const requestOptions = factory({ host: options?.HTTPHost || 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 ?? getDefaultDomain(request.method, request.url);
+            let url = `https://${domain}${request.url}`;
+            if (request.params && request.params.toString()) {
+                url += `?${request.params.toString()}`;
+            }
+            try {
+                const biHeader = 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;
+            }
+        },
+    });
+}
+const errorBuilder = (code, description, details, data) => {
+    return {
+        response: {
+            data: {
+                details: {
+                    ...(!details?.validationError && {
+                        applicationError: {
+                            description,
+                            code,
+                            data,
+                        },
+                    }),
+                    ...details,
+                },
+                message: description,
+            },
+            status: code,
+        },
+    };
+};

package/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/build/tokenHelpers.js

@@ -0,0 +1,11 @@
+export function getCurrentDate() {
+    return Math.floor(Date.now() / 1000);
+}
+export function isTokenExpired(token) {
+    const currentDate = getCurrentDate();
+    return token.expiresAt < currentDate;
+}
+export function createAccessToken(accessToken, expiresIn) {
+    const now = getCurrentDate();
+    return { value: accessToken, expiresAt: Number(expiresIn) + now };
+}

package/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/build/wixClient.js

@@ -0,0 +1,86 @@
+import { toHTTPModule, isAmbassadorModule, ambassadorModuleOptions, } from './ambassador-modules.js';
+import { API_URL, PUBLIC_METADATA_KEY } from './common.js';
+import { getDefaultContentHeader, isObject } from './helpers.js';
+import { buildHostModule, isHostModule } from './host-modules.js';
+import { buildRESTDescriptor } from './rest-modules.js';
+import { FetchErrorResponse } from './fetch-error.js';
+export 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 = 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 (isHostModule(modules) && config.host) {
+            return buildHostModule(modules, config.host);
+        }
+        else if (typeof modules === 'function') {
+            const { module, options } = isAmbassadorModule(modules)
+                ? {
+                    module: toHTTPModule(modules),
+                    options: ambassadorModuleOptions(),
+                }
+                : { module: modules, options: undefined };
+            return buildRESTDescriptor(module, metadata ?? {}, boundFetch, options);
+        }
+        else if (isObject(modules)) {
+            return Object.fromEntries(Object.entries(modules).map(([key, value]) => {
+                return [key, use(value, modules[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://${API_URL}`);
+            finalUrl.host = API_URL;
+            finalUrl.protocol = 'https';
+            return boundFetch(finalUrl.toString(), options);
+        },
+        async graphql(query, variables, opts = {
+            apiVersion: 'alpha',
+        }) {
+            const res = await boundFetch(`https://${API_URL}/graphql/${opts.apiVersion}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ query, variables }),
+            });
+            if (res.status !== 200) {
+                throw new FetchErrorResponse(`GraphQL request failed with status ${res.status}`, res);
+            }
+            const { data, errors } = await res.json();
+            return { data: data ?? {}, errors };
+        },
+    };
+}

package/build/wixMedia.d.ts

@@ -0,0 +1,46 @@
+import { ImageTransformOptions } from '@wix/image-kit';
+declare function getScaledToFillImageUrl(wixMediaIdentifier: string, targetWidth: number, targetHeight: number, options: ImageTransformOptions): string;
+declare function getScaledToFitImageUrl(wixMediaIdentifier: string, targetWidth: number, targetHeight: number, options: ImageTransformOptions): string;
+declare function getCroppedImageUrl(wixMediaIdentifier: string, cropX: number, cropY: number, cropWidth: number, cropHeight: number, targetWidth: number, targetHeight: number, options?: ImageTransformOptions): string;
+declare function getImageUrl(val: string): {
+    id: string;
+    url: string;
+    height: number;
+    width: number;
+    altText?: string;
+    filename?: string;
+};
+declare function getVideoUrl(val: string, resolution?: VideoResolution): {
+    id: string;
+    url: string;
+    thumbnail: string;
+    filename?: string;
+};
+declare function getAudioUrl(val: string): {
+    id: string;
+    url: string;
+    duration: number;
+    filename?: string;
+};
+declare function getDocumentUrl(val: string): {
+    id: string;
+    url: string;
+    filename?: string;
+};
+export declare function decodeText(s: string): string;
+export declare enum VideoResolution {
+    MOBILE = "360p",
+    LOW = "480p",
+    MID = "720p",
+    HIGH = "1080p"
+}
+export declare const media: {
+    getCroppedImageUrl: typeof getCroppedImageUrl;
+    getScaledToFillImageUrl: typeof getScaledToFillImageUrl;
+    getScaledToFitImageUrl: typeof getScaledToFitImageUrl;
+    getImageUrl: typeof getImageUrl;
+    getVideoUrl: typeof getVideoUrl;
+    getAudioUrl: typeof getAudioUrl;
+    getDocumentUrl: typeof getDocumentUrl;
+};
+export {};

package/build/wixMedia.js

@@ -0,0 +1,156 @@
+import { sdk } from '@wix/image-kit';
+const WIX_PROTOCOL = 'wix:';
+const WIX_IMAGE = 'image';
+const WIX_VIDEO = 'video';
+const WIX_AUDIO = 'audio';
+const WIX_DOCUMENT = 'document';
+const WIX_IMAGE_URL = 'https://static.wixstatic.com/media/';
+const WIX_VIDEO_URL = 'https://video.wixstatic.com/video/';
+const WIX_AUDIO_URL = 'https://static.wixstatic.com/mp3/';
+const WIX_DOCUMENT_URL = 'https://d945e594-8657-47e2-9cd9-e9033c3d8da0.usrfiles.com/ugd/';
+function getScaledToFillImageUrl(wixMediaIdentifier, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return sdk.getScaleToFillImageURL(img.id, img.height, img.width, targetWidth, targetHeight, options);
+}
+function getScaledToFitImageUrl(wixMediaIdentifier, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return sdk.getScaleToFitImageURL(img.id, img.height, img.width, targetWidth, targetHeight, options);
+}
+function getCroppedImageUrl(wixMediaIdentifier, cropX, cropY, cropWidth, cropHeight, targetWidth, targetHeight, options) {
+    const img = getImageUrl(wixMediaIdentifier);
+    return sdk.getCropImageURL(img.id, img.height, img.width, cropX, cropY, cropWidth, cropHeight, targetWidth, targetHeight, options);
+}
+function getImageUrl(val) {
+    let id, filenameOrAltText;
+    let height, width;
+    if (val.startsWith(WIX_IMAGE_URL)) {
+        id = val.split(WIX_IMAGE_URL).pop().split('/')[0];
+        width = val.split('/w_').pop().split(',')[0];
+        height = val.split(',h_').pop().split(',')[0];
+    }
+    else {
+        const alignedImage = alignIfLegacy(val, WIX_IMAGE);
+        const { hash, pathname } = new URL(alignedImage);
+        const params = new URLSearchParams(hash.replace('#', ''));
+        height = params.get('originHeight');
+        width = params.get('originWidth');
+        [id, filenameOrAltText] = pathname
+            .replace(`${WIX_IMAGE}://v1/`, '')
+            .split('/');
+    }
+    // @ts-expect-error
+    const decodedFilenameOrAltText = decodeText(filenameOrAltText);
+    const res = {
+        id,
+        url: `${WIX_IMAGE_URL}${id}`,
+        height: Number(height),
+        width: Number(width),
+    };
+    if (!decodedFilenameOrAltText) {
+        return res;
+    }
+    return {
+        ...res,
+        altText: decodedFilenameOrAltText,
+        filename: decodedFilenameOrAltText,
+    };
+}
+function getVideoUrl(val, resolution) {
+    let id, thumbnailId, thumbnailWidth, thumbnailHeight, decodedFilename = '';
+    if (val.startsWith(WIX_VIDEO_URL)) {
+        id = val.split(WIX_VIDEO_URL).pop().split('/')[0];
+        thumbnailId = `${id}.jpg`;
+        thumbnailWidth = '50';
+        thumbnailHeight = '50';
+    }
+    else {
+        const alignedVideo = alignIfLegacy(val, WIX_VIDEO);
+        const { pathname, hash } = new URL(alignedVideo);
+        const hashParams = new URLSearchParams(hash.replace('#', ''));
+        const [_id, fileName] = pathname
+            .replace(`${WIX_VIDEO}://v1/`, '')
+            .split('/');
+        id = _id;
+        thumbnailId = hashParams.get('posterUri') || `${id}.jpg`;
+        thumbnailWidth = hashParams.get('posterWidth') || '50';
+        thumbnailHeight = hashParams.get('posterHeight') || '50';
+        decodedFilename = decodeText(fileName);
+    }
+    const res = {
+        id,
+        url: `${WIX_VIDEO_URL}${id}/${resolution ? `${resolution}/mp4/file.mp4` : 'file'}`,
+        thumbnail: `${WIX_PROTOCOL}${WIX_IMAGE}://v1/${thumbnailId}#originWidth=${thumbnailWidth}&originHeight=${thumbnailHeight}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+function getAudioUrl(val) {
+    const alignedAudio = alignIfLegacy(val, WIX_AUDIO);
+    const { pathname, hash } = new URL(alignedAudio);
+    const [id, filename] = pathname.replace(`${WIX_AUDIO}://v1/`, '').split('/');
+    const decodedFilename = decodeText(filename);
+    const hashParams = new URLSearchParams(hash.replace('#', ''));
+    const res = {
+        id,
+        duration: Number(hashParams.get('duration') || ''),
+        url: `${WIX_AUDIO_URL}${id}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+function getDocumentUrl(val) {
+    const valWithoutUGD = val.replace('v1/ugd', 'v1');
+    const alignedDocument = alignIfLegacy(valWithoutUGD, WIX_DOCUMENT);
+    const { pathname } = new URL(alignedDocument);
+    const [id, filename] = pathname
+        .replace(`${WIX_DOCUMENT}://v1/`, '')
+        .split('/');
+    const decodedFilename = decodeText(filename);
+    const res = {
+        id,
+        url: `${WIX_DOCUMENT_URL}${id}`,
+    };
+    if (!decodedFilename) {
+        return res;
+    }
+    return {
+        ...res,
+        filename: decodedFilename,
+    };
+}
+export function decodeText(s) {
+    if (!s) {
+        return s;
+    }
+    return decodeURIComponent(s);
+}
+function alignIfLegacy(url, type) {
+    const { protocol } = new URL(url);
+    return protocol === `${type}:` ? `${WIX_PROTOCOL}${url}` : url;
+}
+export var VideoResolution;
+(function (VideoResolution) {
+    VideoResolution["MOBILE"] = "360p";
+    VideoResolution["LOW"] = "480p";
+    VideoResolution["MID"] = "720p";
+    VideoResolution["HIGH"] = "1080p";
+})(VideoResolution || (VideoResolution = {}));
+export const media = {
+    getCroppedImageUrl,
+    getScaledToFillImageUrl,
+    getScaledToFitImageUrl,
+    getImageUrl,
+    getVideoUrl,
+    getAudioUrl,
+    getDocumentUrl,
+};

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

@@ -0,0 +1,31 @@
+import type { HttpClient as SDKHttpClient } from '@wix/sdk-types';
+import { RESTModuleOptions } from './rest-modules.js';
+export type RequestContext = {
+    isSSR: boolean;
+    host: string;
+    protocol?: string;
+};
+/**
+ * Ambassador request options types are copied mostly from AxiosRequestConfig.
+ * They are copied and not imported to reduce the amount of dependencies (to reduce install time).
+ * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/index.d.ts#L307-L315
+ */
+export type Method = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
+type ResponseTransformer = (data: any, headers?: any) => any;
+export type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+export type AmbassadorFactory<Request, Response> = (payload: Request) => ((context: RequestContext) => AmbassadorRequestOptions<Response>) & {
+    __isAmbassador: boolean;
+};
+export type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+export type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
+export declare const toHTTPModule: <Request_1, Response_1>(factory: AmbassadorFactory<Request_1, Response_1>) => (httpClient: SDKHttpClient) => (payload: Request_1) => Promise<Response_1>;
+export declare const ambassadorModuleOptions: () => RESTModuleOptions;
+export declare const isAmbassadorModule: (module: any) => boolean;
+export {};

package/cjs/build/ambassador-modules.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAmbassadorModule = exports.ambassadorModuleOptions = exports.toHTTPModule = void 0;
+const parseMethod = (method) => {
+    switch (method) {
+        case 'get':
+        case 'GET':
+            return 'GET';
+        case 'post':
+        case 'POST':
+            return 'POST';
+        case 'put':
+        case 'PUT':
+            return 'PUT';
+        case 'delete':
+        case 'DELETE':
+            return 'DELETE';
+        case 'patch':
+        case 'PATCH':
+            return 'PATCH';
+        case 'head':
+        case 'HEAD':
+            return 'HEAD';
+        case 'options':
+        case 'OPTIONS':
+            return 'OPTIONS';
+        default:
+            throw new Error(`Unknown method: ${method}`);
+    }
+};
+const toHTTPModule = (factory) => (httpClient) => async (payload) => {
+    let requestOptions;
+    const HTTPFactory = (context) => {
+        requestOptions = factory(payload)(context);
+        if (requestOptions.url === undefined) {
+            throw new Error('Url was not successfully created for this request, please reach out to support channels for assistance.');
+        }
+        const { method, url, params } = requestOptions;
+        return {
+            ...requestOptions,
+            method: parseMethod(method),
+            url,
+            data: requestOptions.data,
+            params,
+        };
+    };
+    try {
+        const response = await httpClient.request(HTTPFactory);
+        if (requestOptions === undefined) {
+            throw new Error('Request options were not created for this request, please reach out to support channels for assistance.');
+        }
+        const transformations = Array.isArray(requestOptions.transformResponse)
+            ? requestOptions.transformResponse
+            : [requestOptions.transformResponse];
+        /**
+         * Based on Axios implementation:
+         * https://github.com/axios/axios/blob/3f53eb6960f05a1f88409c4b731a40de595cb825/lib/core/transformData.js#L22
+         */
+        let data = response.data;
+        transformations.forEach((transform) => {
+            if (transform) {
+                data = transform(response.data, response.headers);
+            }
+        });
+        return data;
+    }
+    catch (e) {
+        if (typeof e === 'object' &&
+            e !== null &&
+            'response' in e &&
+            typeof e.response === 'object' &&
+            e.response !== null &&
+            'data' in e.response) {
+            throw e.response.data;
+        }
+        throw e;
+    }
+};
+exports.toHTTPModule = toHTTPModule;
+const ambassadorModuleOptions = () => ({
+    HTTPHost: self.location.host,
+});
+exports.ambassadorModuleOptions = ambassadorModuleOptions;
+/*
+ * Because of issues with tree-shaking, we cant really put static parameter on module.
+ * We still have check for __isAmbassador for backward compatibility
+ */
+const isAmbassadorModule = (module) => {
+    if (module.__isAmbassador) {
+        return true;
+    }
+    const fn = module();
+    return Boolean(fn.__isAmbassador);
+};
+exports.isAmbassadorModule = isAmbassadorModule;

package/cjs/build/auth/ApiKeyAuthStrategy.d.ts

@@ -0,0 +1,16 @@
+import { AuthenticationStrategy } from '@wix/sdk-types';
+export interface IApiKeyStrategy extends AuthenticationStrategy {
+    setSiteId(siteId?: string): void;
+    setAccountId(accountId?: string): void;
+}
+type Context = {
+    siteId: string;
+    accountId?: string;
+} | {
+    siteId?: string;
+    accountId: string;
+};
+export declare function ApiKeyStrategy({ siteId, accountId, apiKey, }: {
+    apiKey: string;
+} & Context): IApiKeyStrategy;
+export {};

package/cjs/build/auth/ApiKeyAuthStrategy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyStrategy = void 0;
+function ApiKeyStrategy({ siteId, accountId, apiKey, }) {
+    const headers = { Authorization: apiKey };
+    if (siteId) {
+        headers['wix-site-id'] = siteId;
+    }
+    if (accountId) {
+        headers['wix-account-id'] = accountId;
+    }
+    return {
+        setSiteId(_siteId) {
+            headers['wix-site-id'] = _siteId;
+        },
+        setAccountId(_accountId) {
+            headers['wix-account-id'] = _accountId;
+        },
+        async getAuthHeaders() {
+            return {
+                headers,
+            };
+        },
+    };
+}
+exports.ApiKeyStrategy = ApiKeyStrategy;