@wix/sdk 1.5.8 → 1.6.0

package/build/cjs/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/build/cjs/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/build/cjs/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/build/cjs/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;

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

@@ -0,0 +1,54 @@
+import { AuthenticationStrategy } from '@wix/sdk-types';
+export type WixAppOAuthStrategy = AuthenticationStrategy & {
+    getInstallUrl({ redirectUrl }: {
+        redirectUrl: string;
+    }): string;
+    handleOAuthCallback(url: string, opts?: {
+        state: string;
+    }): Promise<{
+        instanceId: string;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+};
+/**
+ * Creates an authentication strategy for Wix Apps OAuth installation process.
+ * Use this authentication strategy when making requests to Wix APIs from your Wix App backend.
+ * @param opts Options for initializing the authentication strategy
+ * @param opts.appId The Wix App ID
+ * @param opts.appSecret The Wix App Secret
+ * @param opts.refreshToken An optional refresh token previously retrieved from Wix OAuth API
+ * @returns An authentication strategy that can be used with WixClient
+ * @example
+ * ```ts
+ * import { WixAppOAuthStrategy, createClient } from '@wix/sdk';
+ * import { products } from '@wix/stores';
+ *
+ * const client = createClient({
+ *  auth: WixAppOAuthStrategy({
+ *   appId: 'appId',
+ *   appSecret: 'appSecret',
+ *  }),
+ *  modules: { products },
+ * });
+ *
+ * const installUrl = client.auth.getInstallUrl({ redirectUrl: 'https://example.com' });
+ * // Redirect the user to the installUrl
+ *
+ * ...
+ *
+ * // in the callback handler of your http server
+ * // req.url is the url of the callback request
+ * const { instanceId, refreshToken } = await client.auth.handleOAuthCallback(req.url);
+ *
+ * // store the instanceId and refreshToken in your database
+ * // use the authorized client
+ * const products = await client.products.queryProducts().find();
+ *
+ * ```
+ */
+export declare function WixAppOAuthStrategy(opts: {
+    appId: string;
+    appSecret: string;
+    refreshToken?: string;
+}): WixAppOAuthStrategy;

package/build/cjs/auth/WixAppOAuthStrategy.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WixAppOAuthStrategy = void 0;
+/**
+ * Creates an authentication strategy for Wix Apps OAuth installation process.
+ * Use this authentication strategy when making requests to Wix APIs from your Wix App backend.
+ * @param opts Options for initializing the authentication strategy
+ * @param opts.appId The Wix App ID
+ * @param opts.appSecret The Wix App Secret
+ * @param opts.refreshToken An optional refresh token previously retrieved from Wix OAuth API
+ * @returns An authentication strategy that can be used with WixClient
+ * @example
+ * ```ts
+ * import { WixAppOAuthStrategy, createClient } from '@wix/sdk';
+ * import { products } from '@wix/stores';
+ *
+ * const client = createClient({
+ *  auth: WixAppOAuthStrategy({
+ *   appId: 'appId',
+ *   appSecret: 'appSecret',
+ *  }),
+ *  modules: { products },
+ * });
+ *
+ * const installUrl = client.auth.getInstallUrl({ redirectUrl: 'https://example.com' });
+ * // Redirect the user to the installUrl
+ *
+ * ...
+ *
+ * // in the callback handler of your http server
+ * // req.url is the url of the callback request
+ * const { instanceId, refreshToken } = await client.auth.handleOAuthCallback(req.url);
+ *
+ * // store the instanceId and refreshToken in your database
+ * // use the authorized client
+ * const products = await client.products.queryProducts().find();
+ *
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+function WixAppOAuthStrategy(opts) {
+    let refreshToken = opts.refreshToken;
+    return {
+        getInstallUrl({ redirectUrl }) {
+            return `https://www.wix.com/installer/install?appId=${opts.appId}&redirectUrl=${redirectUrl}`;
+        },
+        async handleOAuthCallback(url, oauthOpts) {
+            const params = new URLSearchParams(new URL(url).search);
+            const state = params.get('state');
+            if (state && oauthOpts?.state && state !== oauthOpts.state) {
+                throw new Error(`Invalid OAuth callback URL. Expected state to be "${oauthOpts.state}" but got "${state}"`);
+            }
+            const code = params.get('code');
+            const instanceId = params.get('instanceId');
+            if (!code || !instanceId) {
+                throw new Error('Invalid OAuth callback URL. Make sure you pass the url including the code and instanceId query params.');
+            }
+            const tokensRes = await fetch('https://www.wixapis.com/oauth/access', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    code,
+                    client_id: opts.appId,
+                    client_secret: opts.appSecret,
+                    grant_type: 'authorization_code',
+                }),
+            });
+            if (tokensRes.status !== 200) {
+                throw new Error(`Failed to exchange authorization code for refresh token. Unexpected status code from Wix OAuth API: ${tokensRes.status}`);
+            }
+            const tokens = await tokensRes.json();
+            refreshToken = tokens.refresh_token;
+            return {
+                instanceId,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+            };
+        },
+        async getAuthHeaders() {
+            if (!refreshToken) {
+                throw new Error('Missing refresh token. Either pass it to the WixAppOAuthStrategy or use the handleOAuthCallback method to retrieve it.');
+            }
+            const tokensRes = await fetch('https://www.wixapis.com/oauth/access', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    refresh_token: refreshToken,
+                    client_id: opts.appId,
+                    client_secret: opts.appSecret,
+                    grant_type: 'refresh_token',
+                }),
+            });
+            if (tokensRes.status !== 200) {
+                throw new Error(`Failed to exchange refresh token for access token. Unexpected status code from Wix OAuth API: ${tokensRes.status}`);
+            }
+            const tokens = (await tokensRes.json());
+            refreshToken = tokens.refresh_token;
+            return {
+                headers: {
+                    Authorization: tokens.access_token,
+                },
+            };
+        },
+    };
+}
+exports.WixAppOAuthStrategy = WixAppOAuthStrategy;

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

@@ -0,0 +1,12 @@
+import { IOAuthStrategy, Tokens } from './types.js';
+export declare function OAuthStrategy(config: {
+    clientId: string;
+    tokens?: Tokens;
+}): IOAuthStrategy;
+export interface TokenResponse {
+    access_token: string;
+    expires_in: number;
+    refresh_token: string | null;
+    token_type: string;
+    scope?: string | null;
+}