@wix/sdk 1.2.8 → 1.4.0

package/build/browser/index.mjs

@@ -1,3 +1,73 @@
+// src/ambassador-modules.ts
+import { transformError } from "@wix/metro-runtime/velo";
+var 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}`);
+  }
+};
+var toHTTPModule = (factory) => (httpClient) => async (payload) => {
+  let requestOptions;
+  const HTTPFactory = (context) => {
+    requestOptions = factory(payload)(context);
+    if (requestOptions.url === void 0) {
+      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 === void 0) {
+      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];
+    let data = response.data;
+    transformations.forEach((transform) => {
+      if (transform) {
+        data = transform(response.data, response.headers);
+      }
+    });
+    return data;
+  } catch (e) {
+    throw transformError(e);
+  }
+};
+var ambassadorModuleOptions = () => ({
+  HTTPHost: self.location.host
+});
+
 // src/common.ts
 var PUBLIC_METADATA_KEY = "__metadata";
 var API_URL = "www.wixapis.com";
@@ -37,22 +107,27 @@ function objectToKeyValue(input) {
 }
 
 // src/rest-modules.ts
-function buildRESTDescriptor(origFunc, publicMetadata, boundFetch) {
+function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, options) {
   return origFunc({
     request: async (factory) => {
-      var _a;
-      const requestOptions = factory({ host: API_URL });
-      const domain = requestOptions.method === "GET" && !FORCE_WRITE_API_URLS.some((url2) => requestOptions.url === url2) ? READ_ONLY_API_URL : API_URL;
-      let url = `https://${domain}${requestOptions.url}`;
-      if (requestOptions.params && requestOptions.params.toString()) {
-        url += `?${requestOptions.params.toString()}`;
+      var _a, _b, _c;
+      const requestOptions = factory({ host: (options == null ? void 0 : options.HTTPHost) || API_URL });
+      let request = requestOptions;
+      if (request.method === "GET" && ((_a = request.fallback) == null ? void 0 : _a.length) && request.params.toString().length > 4e3) {
+        request = requestOptions.fallback[0];
+      }
+      const getDefaultDomain = () => request.method === "GET" && !FORCE_WRITE_API_URLS.some((url2) => request.url === url2) ? READ_ONLY_API_URL : API_URL;
+      const domain = (_b = options == null ? void 0 : options.HTTPHost) != null ? _b : getDefaultDomain();
+      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: requestOptions.method,
-          ...requestOptions.data && {
-            body: JSON.stringify(requestOptions.data)
+          method: request.method,
+          ...request.data && {
+            body: JSON.stringify(request.data)
           },
           headers: {
             ...biHeader
@@ -82,7 +157,7 @@ function buildRESTDescriptor(origFunc, publicMetadata, boundFetch) {
           statusText: res.statusText
         };
       } catch (e) {
-        if ((_a = e.message) == null ? void 0 : _a.includes("fetch is not defined")) {
+        if ((_c = e.message) == null ? void 0 : _c.includes("fetch is not defined")) {
           console.error("Node.js v18+ is required");
         }
         throw e;
@@ -134,10 +209,15 @@ function createClient(config) {
     if (isHostModule(modules) && config.host) {
       return buildHostModule(modules, config.host);
     } else if (typeof modules === "function") {
+      const { module, options } = modules.__isAmbassador ? {
+        module: toHTTPModule(modules),
+        options: ambassadorModuleOptions()
+      } : { module: modules, options: void 0 };
       return buildRESTDescriptor(
-        modules,
+        module,
         metadata != null ? metadata : {},
-        boundFetch
+        boundFetch,
+        options
       );
     } else if (isObject(modules)) {
       return Object.fromEntries(
@@ -362,7 +442,6 @@ function OAuthStrategy(config) {
     _tokens.refreshToken = tokens.refreshToken;
   };
   let _state = {
-    stateKind: "initial",
     loginState: "INITIAL" /* INITIAL */
   };
   const getAuthHeaders = async () => {
@@ -525,24 +604,20 @@ function OAuthStrategy(config) {
     if (response.state === authentication.StateType.SUCCESS) {
       return {
         loginState: "SUCCESS" /* SUCCESS */,
-        stateKind: "success",
         data: { sessionToken: response.sessionToken }
       };
     } else if (response.state === authentication.StateType.REQUIRE_OWNER_APPROVAL) {
       return {
-        loginState: "OWNER_APPROVAL_REQUIRED" /* OWNER_APPROVAL_REQUIRED */,
-        stateKind: "ownerApprovalRequired"
+        loginState: "OWNER_APPROVAL_REQUIRED" /* OWNER_APPROVAL_REQUIRED */
       };
     } else if (response.state === authentication.StateType.REQUIRE_EMAIL_VERIFICATION) {
       _state = {
         loginState: "EMAIL_VERIFICATION_REQUIRED" /* EMAIL_VERIFICATION_REQUIRED */,
-        stateKind: "emailVerificationRequired",
         data: { stateToken: response.stateToken }
       };
       return _state;
     }
     return {
-      stateKind: "failure",
       loginState: "FAILURE" /* FAILURE */,
       error: "Unknown _state"
     };
@@ -574,7 +649,6 @@ function OAuthStrategy(config) {
       );
       if (emailValidation) {
         return {
-          stateKind: "failure",
           loginState: "FAILURE" /* FAILURE */,
           error: emailValidation.description,
           errorCode: "invalidEmail"
@@ -582,7 +656,6 @@ function OAuthStrategy(config) {
       }
       if (((_e = e.details.applicationError) == null ? void 0 : _e.code) === MISSING_CAPTCHA) {
         return {
-          stateKind: "failure",
           loginState: "FAILURE" /* FAILURE */,
           error: e.message,
           errorCode: "missingCaptchaToken"
@@ -590,7 +663,6 @@ function OAuthStrategy(config) {
       }
       if (((_f = e.details.applicationError) == null ? void 0 : _f.code) === EMAIL_EXISTS) {
         return {
-          stateKind: "failure",
           loginState: "FAILURE" /* FAILURE */,
           error: e.message,
           errorCode: "emailAlreadyExists"
@@ -598,14 +670,12 @@ function OAuthStrategy(config) {
       }
       if (((_g = e.details.applicationError) == null ? void 0 : _g.code) === INVALID_CAPTCHA) {
         return {
-          stateKind: "failure",
           loginState: "FAILURE" /* FAILURE */,
           error: e.message,
           errorCode: "invalidCaptchaToken"
         };
       }
       return {
-        stateKind: "failure",
         loginState: "FAILURE" /* FAILURE */,
         error: e.message
       };
@@ -633,25 +703,24 @@ function OAuthStrategy(config) {
       return handleState(res);
     } catch (e) {
       return {
-        stateKind: "failure",
         loginState: "FAILURE" /* FAILURE */,
         error: e.message,
         errorCode: ((_c = e.details.applicationError) == null ? void 0 : _c.code) === MISSING_CAPTCHA ? "missingCaptchaToken" : ((_d = e.details.applicationError) == null ? void 0 : _d.code) === INVALID_CAPTCHA ? "invalidCaptchaToken" : e.details.applicationError.code === INVALID_PASSWORD ? "invalidPassword" : e.details.applicationError.code === RESET_PASSWORD ? "resetPassword" : "invalidEmail"
       };
     }
   };
-  const processVerification = async (nextInputs) => {
+  const processVerification = async (nextInputs, state) => {
     var _a;
-    if (_state.stateKind === "emailVerificationRequired") {
+    const stateToUse = state != null ? state : _state;
+    if (stateToUse.loginState === "EMAIL_VERIFICATION_REQUIRED" /* EMAIL_VERIFICATION_REQUIRED */) {
       const code = (_a = nextInputs.verificationCode) != null ? _a : nextInputs.code;
       const res = await wixClientWithTokens.verification.verifyDuringAuthentication(
         code,
-        { stateToken: _state.data.stateToken }
+        { stateToken: stateToUse.data.stateToken }
       );
       return handleState(res);
     }
     return {
-      stateKind: "failure",
       loginState: "FAILURE" /* FAILURE */,
       error: "Unknown _state"
     };
@@ -696,18 +765,9 @@ function OAuthStrategy(config) {
     loggedIn,
     logout,
     register,
-    proceed: (nextInputs) => {
-      const { code, ...restProps } = nextInputs;
-      return processVerification({
-        verificationCode: code,
-        ...restProps
-      });
-    },
     processVerification,
     login,
-    complete: getMemberTokensForDirectLogin,
     getMemberTokensForDirectLogin,
-    sendResetPasswordMail: sendPasswordResetEmail,
     sendPasswordResetEmail,
     captchaInvisibleSiteKey: "6LdoPaUfAAAAAJphvHoUoOob7mx0KDlXyXlgrx5v",
     captchaVisibleSiteKey: "6Ld0J8IcAAAAANyrnxzrRlX1xrrdXsOmsepUYosy"
@@ -761,13 +821,96 @@ function ApiKeyStrategy({
   };
 }
 
+// src/auth/WixAppOAuthStrategy.ts
+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 == null ? void 0 : 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
+        }
+      };
+    }
+  };
+}
+
 // src/index.ts
 export * from "@wix/sdk-types";
 export {
+  API_URL,
   ApiKeyStrategy,
   LoginState,
   OAuthStrategy,
   TokenRole,
+  WixAppOAuthStrategy,
   createClient,
   decodeText,
   media

package/build/index.d.mts

@@ -7,6 +7,34 @@ import { authentication } from '@wix/identity';
 type PublicMetadata = {
     PACKAGE_NAME?: string;
 };
+declare const API_URL = "www.wixapis.com";
+
+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
+ */
+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;
+type AmbassadorRequestOptions<T = any> = {
+    _?: T;
+    url?: string;
+    method?: Method;
+    params?: any;
+    data?: any;
+    transformResponse?: ResponseTransformer | ResponseTransformer[];
+};
+type AmbassadorFactory<Request, Response> = {
+    (payload: Request): (context: RequestContext) => AmbassadorRequestOptions<Response>;
+    __isAmbassador: boolean;
+};
+type AmbassadorFunctionDescriptor<Request = any, Response = any> = AmbassadorFactory<Request, Response>;
+type BuildAmbassadorFunction<T extends AmbassadorFunctionDescriptor> = T extends AmbassadorFunctionDescriptor<infer Request, infer Response> ? (req: Request) => Promise<Response> : never;
 
 type Headers = {
     Authorization: string;
@@ -17,10 +45,13 @@ type Headers = {
  * 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).
  */
-type BuildDescriptors<T extends Descriptors, H extends Host<any> | undefined> = BuildRESTDescriptors<T> & (H extends Host<any> ? BuildHostDescriptors<T> : {});
+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>;
@@ -29,7 +60,7 @@ type BuildHostDescriptors<T extends Descriptors> = T extends HostModule<any, any
  * can either be a REST module or a host module.
  * This type is recursive, so it can describe nested modules.
  */
-type Descriptors = RESTFunctionDescriptor | HostModule<any, any> | {
+type Descriptors = RESTFunctionDescriptor | AmbassadorFunctionDescriptor | HostModule<any, any> | {
     [key: string]: Descriptors | PublicMetadata | any;
 };
 /**
@@ -136,20 +167,8 @@ interface IOAuthStrategy extends AuthenticationStrategy {
     };
     register: (params: RegisterParams) => Promise<StateMachine>;
     login: (params: LoginParams) => Promise<StateMachine>;
-    processVerification<T extends ProcessableState>(nextInputs: CalculateNextState<T>): Promise<StateMachine>;
-    /**
-     * @deprecated use processVerification instead
-     */
-    proceed<T extends ProcessableState>(nextInputs: DeprecatedCalculateNextState<T>): Promise<StateMachine>;
-    /**
-     * @deprecated use getMemberTokensForDirectLogin instead
-     */
-    complete: (sessionToken: string) => Promise<Tokens>;
+    processVerification<T extends ProcessableState>(nextInputs: CalculateNextState<T>, state?: StateMachine): Promise<StateMachine>;
     getMemberTokensForDirectLogin: (sessionToken: string) => Promise<Tokens>;
-    /**
-     * @deprecated use sendPasswordResetEmail instead
-     */
-    sendResetPasswordMail: (email: string, redirectUri: string) => Promise<void>;
     sendPasswordResetEmail: (email: string, redirectUri: string) => Promise<void>;
     captchaInvisibleSiteKey: string;
     captchaVisibleSiteKey: string;
@@ -164,37 +183,33 @@ declare enum LoginState {
     USER_CAPTCHA_REQUIRED = "USER_CAPTCHA_REQUIRED",
     SILENT_CAPTCHA_REQUIRED = "SILENT_CAPTCHA_REQUIRED"
 }
-interface LoginResults<SK extends string, LK extends LoginState> {
-    /**
-     * @deprecated use loginState instead
-     */
-    stateKind: SK;
+interface LoginResults<LK extends LoginState> {
     loginState: LK;
 }
-interface SuccessState extends LoginResults<'success', LoginState.SUCCESS> {
+interface SuccessState extends LoginResults<LoginState.SUCCESS> {
     data: {
         sessionToken: string;
     };
 }
-interface InitialState extends LoginResults<'initial', LoginState.INITIAL> {
+interface InitialState extends LoginResults<LoginState.INITIAL> {
 }
-interface ErrorState extends LoginResults<'failure', LoginState.FAILURE> {
+interface ErrorState extends LoginResults<LoginState.FAILURE> {
     errorCode?: 'invalidEmail' | 'invalidPassword' | 'resetPassword' | 'missingCaptchaToken' | 'emailAlreadyExists' | 'invalidCaptchaToken';
     error: string;
 }
-interface EmailVerificationRequiredState extends LoginResults<'emailVerificationRequired', LoginState.EMAIL_VERIFICATION_REQUIRED> {
+interface EmailVerificationRequiredState extends LoginResults<LoginState.EMAIL_VERIFICATION_REQUIRED> {
     data: {
         stateToken: string;
     };
 }
-interface OwnerApprovalRequiredState extends LoginResults<'ownerApprovalRequired', LoginState.OWNER_APPROVAL_REQUIRED> {
+interface OwnerApprovalRequiredState extends LoginResults<LoginState.OWNER_APPROVAL_REQUIRED> {
 }
-interface SilentCaptchaRequiredState extends LoginResults<'silentCaptchaRequired', LoginState.SILENT_CAPTCHA_REQUIRED> {
+interface SilentCaptchaRequiredState extends LoginResults<LoginState.SILENT_CAPTCHA_REQUIRED> {
     data: {
         stateToken: string;
     };
 }
-interface UserCaptchaRequiredState extends LoginResults<'userCaptchaRequired', LoginState.USER_CAPTCHA_REQUIRED> {
+interface UserCaptchaRequiredState extends LoginResults<LoginState.USER_CAPTCHA_REQUIRED> {
     data: {
         stateToken: string;
     };
@@ -205,16 +220,9 @@ declare enum TokenRole {
     MEMBER = "member"
 }
 type StateMachine = InitialState | SuccessState | ErrorState | EmailVerificationRequiredState | OwnerApprovalRequiredState | SilentCaptchaRequiredState | UserCaptchaRequiredState;
-type DeprecatedCode = {
-    /**
-     * @deprecated use verificationCode instead
-     */
-    code: string;
-};
 type VerificationCode = {
     verificationCode: string;
 };
-type DeprecatedCalculateNextState<T> = T extends EmailVerificationRequiredState ? DeprecatedCode : never;
 type CalculateNextState<T> = T extends EmailVerificationRequiredState ? VerificationCode : never;
 type ProcessableState = EmailVerificationRequiredState;
 
@@ -245,4 +253,58 @@ declare function ApiKeyStrategy({ siteId, accountId, apiKey, }: {
     apiKey: string;
 } & Context): IApiKeyStrategy;
 
-export { AccessToken, ApiKeyStrategy, AssertHostMatches, BuildDescriptors, CalculateNextState, DeprecatedCalculateNextState, Descriptors, IApiKeyStrategy, IOAuthStrategy, LoginParams, LoginState, OAuthStrategy, OauthData, OauthPKCE, ProcessableState, RefreshToken, RegisterParams, StateMachine, Token, TokenResponse, TokenRole, Tokens, WixClient, createClient, decodeText, media };
+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();
+ *
+ * ```
+ */
+declare function WixAppOAuthStrategy(opts: {
+    appId: string;
+    appSecret: string;
+    refreshToken?: string;
+}): WixAppOAuthStrategy;
+
+export { API_URL, AccessToken, ApiKeyStrategy, AssertHostMatches, BuildDescriptors, CalculateNextState, Descriptors, IApiKeyStrategy, IOAuthStrategy, LoginParams, LoginState, OAuthStrategy, OauthData, OauthPKCE, ProcessableState, RefreshToken, RegisterParams, StateMachine, Token, TokenResponse, TokenRole, Tokens, WixAppOAuthStrategy, WixClient, createClient, decodeText, media };