@wix/cli-app 1.1.107 → 1.1.109

package/build/cloudflare-runtime/getRegisteredExtensions.js

@@ -4438,7 +4438,7 @@ function objectToKeyValue(input) {
   return Object.entries(input).filter(([_, value]) => Boolean(value)).map(([key, value]) => `${key}=${value}`).join(",");
 }
 
-// ../../node_modules/@wix/sdk-runtime/build/context.js
+// ../../node_modules/@wix/sdk/node_modules/@wix/sdk-runtime/build/context.js
 function runWithoutContext(fn) {
   const globalContext = globalThis.__wix_context__;
   const moduleContext = {
@@ -4470,8 +4470,189 @@ function runWithoutContext(fn) {
   }
 }
 
+// ../../node_modules/@wix/sdk/node_modules/@wix/sdk-runtime/build/utils.js
+function constantCase(input) {
+  return split(input).map((part) => part.toLocaleUpperCase()).join("_");
+}
+var SPLIT_LOWER_UPPER_RE = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu");
+var SPLIT_UPPER_UPPER_RE = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0") {
+    start++;
+  }
+  if (start === end) {
+    return [];
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--;
+  }
+  return result.slice(start, end).split(/\0/g);
+}
+
+// ../../node_modules/@wix/sdk/node_modules/@wix/sdk-runtime/build/transform-error.js
+var isValidationError = (httpClientError) => "validationError" in (httpClientError.response?.data?.details ?? {});
+var isApplicationError = (httpClientError) => "applicationError" in (httpClientError.response?.data?.details ?? {});
+var isClientError = (httpClientError) => (httpClientError.response?.status ?? -1) >= 400 && (httpClientError.response?.status ?? -1) < 500;
+function transformError(httpClientError, pathsToArguments = {
+  explicitPathsToArguments: {},
+  spreadPathsToArguments: {},
+  singleArgumentUnchanged: false
+}, argumentNames = []) {
+  if (typeof httpClientError !== "object" || httpClientError === null) {
+    throw httpClientError;
+  }
+  if (isValidationError(httpClientError)) {
+    return buildValidationError(httpClientError, pathsToArguments, argumentNames);
+  }
+  if (isApplicationError(httpClientError)) {
+    return buildApplicationError(httpClientError);
+  }
+  if (isClientError(httpClientError)) {
+    const status = httpClientError.response?.status;
+    const statusText = httpClientError.response?.statusText ?? "UNKNOWN";
+    const message2 = httpClientError.response?.data?.message ?? statusText;
+    const details = {
+      applicationError: {
+        description: statusText,
+        code: constantCase(statusText),
+        data: {}
+      },
+      requestId: httpClientError.requestId
+    };
+    return wrapError(httpClientError, {
+      message: JSON.stringify({
+        message: message2,
+        details
+      }, null, 2),
+      extraProperties: {
+        details,
+        status
+      }
+    });
+  }
+  return buildSystemError(httpClientError);
+}
+var buildValidationError = (httpClientError, pathsToArguments, argumentNames) => {
+  const validationErrorResponse = httpClientError.response?.data;
+  const requestId = httpClientError.requestId;
+  const { fieldViolations } = validationErrorResponse.details.validationError;
+  const transformedFieldViolations = violationsWithRenamedFields(pathsToArguments, fieldViolations, argumentNames)?.sort((a, b) => a.field < b.field ? -1 : 1);
+  const message2 = `INVALID_ARGUMENT: ${transformedFieldViolations?.map(({ field, description }) => `"${field}" ${description}`)?.join(", ")}`;
+  const details = {
+    validationError: { fieldViolations: transformedFieldViolations },
+    requestId
+  };
+  return wrapError(httpClientError, {
+    message: JSON.stringify({ message: message2, details }, null, 2),
+    extraProperties: {
+      details,
+      status: httpClientError.response?.status,
+      requestId
+    }
+  });
+};
+var wrapError = (baseError, { message: message2, extraProperties }) => {
+  return Object.assign(baseError, {
+    ...extraProperties,
+    message: message2
+  });
+};
+var buildApplicationError = (httpClientError) => {
+  const status = httpClientError.response?.status;
+  const statusText = httpClientError.response?.statusText ?? "UNKNOWN";
+  const message2 = httpClientError.response?.data?.message ?? statusText;
+  const description = httpClientError.response?.data?.details?.applicationError?.description ?? statusText;
+  const code = httpClientError.response?.data?.details?.applicationError?.code ?? constantCase(statusText);
+  const data = httpClientError.response?.data?.details?.applicationError?.data ?? {};
+  const combinedMessage = message2 === description ? message2 : `${message2}: ${description}`;
+  const details = {
+    applicationError: {
+      description,
+      code,
+      data
+    },
+    requestId: httpClientError.requestId
+  };
+  return wrapError(httpClientError, {
+    message: JSON.stringify({ message: combinedMessage, details }, null, 2),
+    extraProperties: {
+      details,
+      status,
+      requestId: httpClientError.requestId
+    }
+  });
+};
+var buildSystemError = (httpClientError) => {
+  const message2 = httpClientError.requestId ? `System error occurred, request-id: ${httpClientError.requestId}` : `System error occurred: ${JSON.stringify(httpClientError)}`;
+  return wrapError(httpClientError, {
+    message: message2,
+    extraProperties: {
+      requestId: httpClientError.requestId,
+      status: httpClientError.response?.status,
+      code: constantCase(httpClientError.response?.statusText ?? "UNKNOWN"),
+      ...!httpClientError.response && {
+        runtimeError: httpClientError
+      }
+    }
+  });
+};
+var violationsWithRenamedFields = ({ spreadPathsToArguments, explicitPathsToArguments, singleArgumentUnchanged }, fieldViolations, argumentNames) => {
+  const allPathsToArguments = {
+    ...spreadPathsToArguments,
+    ...explicitPathsToArguments
+  };
+  const allPathsToArgumentsKeys = Object.keys(allPathsToArguments);
+  return fieldViolations?.filter((fieldViolation) => {
+    const containedInAMoreSpecificViolationField = fieldViolations.some((anotherViolation) => anotherViolation.field.length > fieldViolation.field.length && anotherViolation.field.startsWith(fieldViolation.field) && allPathsToArgumentsKeys.includes(anotherViolation.field));
+    return !containedInAMoreSpecificViolationField;
+  }).map((fieldViolation) => {
+    const exactMatchArgumentExpression = explicitPathsToArguments[fieldViolation.field];
+    if (exactMatchArgumentExpression) {
+      return {
+        ...fieldViolation,
+        field: withRenamedArgument(exactMatchArgumentExpression, argumentNames)
+      };
+    }
+    const longestPartialPathMatch = allPathsToArgumentsKeys?.sort((a, b) => b.length - a.length)?.find((path) => fieldViolation.field.startsWith(path));
+    if (longestPartialPathMatch) {
+      const partialMatchArgumentExpression = allPathsToArguments[longestPartialPathMatch];
+      if (partialMatchArgumentExpression) {
+        return {
+          ...fieldViolation,
+          field: fieldViolation.field.replace(longestPartialPathMatch, withRenamedArgument(partialMatchArgumentExpression, argumentNames))
+        };
+      }
+    }
+    if (singleArgumentUnchanged) {
+      return {
+        ...fieldViolation,
+        field: `${argumentNames[0]}.${fieldViolation.field}`
+      };
+    }
+    return fieldViolation;
+  });
+};
+var withRenamedArgument = (fieldValue, argumentNames) => {
+  const argIndex = getArgumentIndex(fieldValue);
+  if (argIndex !== null && typeof argIndex !== "undefined") {
+    return fieldValue.replace(`$[${argIndex}]`, argumentNames[argIndex]);
+  }
+  return fieldValue;
+};
+var getArgumentIndex = (s) => {
+  const match = s.match(/\$\[(?<argIndex>\d+)\]/);
+  return match && match.groups && Number(match.groups.argIndex);
+};
+
 // ../../node_modules/@wix/sdk/build/rest-modules.js
-function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, wixAPIFetch, getActiveToken, options, hostName, useCDN) {
+function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, errorHandler, wixAPIFetch, getActiveToken, options, hostName, useCDN) {
   return runWithoutContext(() => origFunc({
     request: async (factory) => {
       const requestOptions = factory({
@@ -4488,7 +4669,7 @@ function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, wixAPIFetch,
       }
       try {
         const biHeader = biHeaderGenerator(requestOptions, publicMetadata, hostName);
-        const res = await boundFetch(url, {
+        const requestOptionsInit = {
           method: request.method,
           ...request.data && {
             body: JSON.stringify(request.data)
@@ -4496,17 +4677,28 @@ function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, wixAPIFetch,
           headers: {
             ...biHeader
           }
-        });
+        };
+        const res = await boundFetch(url, requestOptionsInit);
         if (res.status !== 200) {
           let dataError = null;
           try {
             dataError = await res.json();
           } catch (e) {
           }
-          throw errorBuilder2(res.status, dataError?.message, dataError?.details, {
+          const error = errorBuilder2(res.status, dataError?.message, dataError?.details, {
             requestId: res.headers.get("X-Wix-Request-Id"),
             details: dataError
           });
+          const transformedError = transformError(error);
+          errorHandler?.handleError(transformedError, {
+            requestOptions: {
+              url: request.url,
+              method: request.method,
+              entityFqdn: requestOptions.entityFqdn,
+              methodFqn: requestOptions.methodFqn
+            }
+          });
+          throw error;
         }
         const data = await res.json();
         return {
@@ -4527,8 +4719,17 @@ function buildRESTDescriptor(origFunc, publicMetadata, boundFetch, wixAPIFetch,
     getActiveToken
   }));
 }
+var SDKError = class extends Error {
+  response;
+  requestId;
+  constructor(params) {
+    super();
+    this.response = params.response;
+    this.requestId = params.requestId;
+  }
+};
 var errorBuilder2 = (code, description, details, data) => {
-  return {
+  return new SDKError({
     response: {
       data: {
         details: {
@@ -4546,7 +4747,7 @@ var errorBuilder2 = (code, description, details, data) => {
       status: code
     },
     requestId: data?.requestId
-  };
+  });
 };
 
 // ../../node_modules/@wix/sdk/build/nanoevents.js
@@ -4788,28 +4989,51 @@ function createClient(config) {
       ...config.host?.essentials?.passThroughHeaders,
       ..._headers[X_WIX_CONSISTENT_HEADER] ? { [X_WIX_CONSISTENT_HEADER]: _headers[X_WIX_CONSISTENT_HEADER] } : {}
     };
-    if (typeof urlOrRequest === "string" || urlOrRequest instanceof URL) {
-      const response = await fetch(urlOrRequest, {
-        ...requestInit,
-        headers
-      });
-      const consistentHeader = findConsistentHeader(response);
-      if (consistentHeader) {
-        _headers[X_WIX_CONSISTENT_HEADER] = consistentHeader;
-      }
-      return response;
-    } else {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          urlOrRequest.headers.set(k, v);
+    const errorHandler = config.host?.getErrorHandler?.();
+    try {
+      if (typeof urlOrRequest === "string" || urlOrRequest instanceof URL) {
+        const response = await fetch(urlOrRequest, {
+          ...requestInit,
+          headers
+        });
+        errorHandler?.handleError(response, {
+          requestOptions: {
+            url: urlOrRequest.toString(),
+            method: requestInit?.method
+          }
+        });
+        const consistentHeader = findConsistentHeader(response);
+        if (consistentHeader) {
+          _headers[X_WIX_CONSISTENT_HEADER] = consistentHeader;
         }
+        return response;
+      } else {
+        for (const [k, v] of Object.entries(headers)) {
+          if (typeof v === "string") {
+            urlOrRequest.headers.set(k, v);
+          }
+        }
+        const response = await fetch(urlOrRequest, requestInit);
+        errorHandler?.handleError(response, {
+          requestOptions: {
+            url: urlOrRequest.url,
+            method: requestInit?.method
+          }
+        });
+        const consistentHeader = findConsistentHeader(response);
+        if (consistentHeader) {
+          _headers[X_WIX_CONSISTENT_HEADER] = consistentHeader;
+        }
+        return response;
       }
-      const response = await fetch(urlOrRequest, requestInit);
-      const consistentHeader = findConsistentHeader(response);
-      if (consistentHeader) {
-        _headers[X_WIX_CONSISTENT_HEADER] = consistentHeader;
-      }
-      return response;
+    } catch (e) {
+      errorHandler?.handleError(e, {
+        requestOptions: {
+          url: typeof urlOrRequest === "string" || urlOrRequest instanceof URL ? urlOrRequest.toString() : urlOrRequest.url,
+          method: requestInit?.method
+        }
+      });
+      throw e;
     }
   };
   const { client: servicePluginsClient, initModule: initServicePluginModule } = servicePluginsModules(authStrategy);
@@ -4848,7 +5072,7 @@ function createClient(config) {
       }
       const apiBaseUrl = config.host?.apiBaseUrl ?? DEFAULT_API_URL;
       const shouldUseCDN = config.useCDN === void 0 ? config.auth?.shouldUseCDN : config.useCDN;
-      return buildRESTDescriptor(runWithoutContext(() => isAmbassadorModule(modules)) ? toHTTPModule(modules) : modules, metadata ?? {}, boundFetch, (relativeUrl, fetchOptions) => {
+      return buildRESTDescriptor(runWithoutContext(() => isAmbassadorModule(modules)) ? toHTTPModule(modules) : modules, metadata ?? {}, boundFetch, config.host?.getErrorHandler?.(), (relativeUrl, fetchOptions) => {
         const finalUrl = new URL(relativeUrl, `https://${apiBaseUrl}`);
         finalUrl.host = apiBaseUrl;
         finalUrl.protocol = "https";

package/build/index.js

@@ -3,18 +3,18 @@ const require = _createRequire(import.meta.url);
 import {
   createI18nT,
   docsExtensionTypeSchema
-} from "./chunk-7B3P7MZT.js";
+} from "./chunk-YHTG4FUT.js";
 import {
   runCommand
-} from "./chunk-VV6PV2NF.js";
-import "./chunk-GFXZXRO4.js";
-import "./chunk-5ZI5USPK.js";
-import "./chunk-657KFISY.js";
+} from "./chunk-JZWZBBAJ.js";
+import "./chunk-4GWPHNUS.js";
+import "./chunk-ZHQREOZP.js";
+import "./chunk-PRD4POH5.js";
 import {
   package_default,
   require_react,
   z
-} from "./chunk-VCFM6SMQ.js";
+} from "./chunk-2KUXKFJH.js";
 import {
   __commonJS,
   __require,
@@ -3377,33 +3377,14 @@ var {
 // src/commands/build.ts
 init_esm_shims();
 var buildCommand = (services) => createCommand("build").action(async (_, command) => {
-  const { runCommand: runCommand2 } = await import("./render-command-FI2MU2Z5.js");
-  const { build } = await import("./build-ZO7CXGLN.js");
+  const { runCommand: runCommand2 } = await import("./render-command-C6PXMRQM.js");
+  const { build } = await import("./build-R56FZRMN.js");
   await runCommand2(command, services, build);
 });
 
 // src/commands/dev.tsx
 init_esm_shims();
 var import_react = __toESM(require_react(), 1);
-var devCommand = (services) => {
-  const t = createI18nT();
-  return createCommand("dev").option("-s, --https", t("dev_command_def.option.https")).action(async (options, command) => {
-    const { DevCommand } = await import("./DevCommand-BWRRKEE6.js");
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
-    const { https = false } = options;
-    await renderCommand(command, services, /* @__PURE__ */ import_react.default.createElement(DevCommand, { https }), {
-      watchForModelChanges: true
-    });
-  });
-};
-
-// src/commands/preview.tsx
-init_esm_shims();
-var import_react2 = __toESM(require_react(), 1);
-
-// ../cli-command-contract/src/index.ts
-init_esm_shims();
-var NO_TTY_JSON_OUTPUT_OPTION = "--json";
 
 // src/commands/validations.ts
 init_esm_shims();
@@ -3421,6 +3402,15 @@ function validateBase(value) {
   }
   throw new InvalidArgumentError("Value must be a valid URL");
 }
+function validatePort(value) {
+  const parsed = z.coerce.number().int().gte(1e3).lte(65535).safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new InvalidArgumentError(
+    `Port must be a valid number between 1000 and 65535`
+  );
+}
 function validateDocsExtensionType(value) {
   const parsed = docsExtensionTypeSchema.safeParse(value);
   if (parsed.success) {
@@ -3447,6 +3437,34 @@ function validateReleaseComment(value) {
   );
 }
 
+// src/commands/dev.tsx
+var devCommand = (services) => {
+  const t = createI18nT();
+  return createCommand("dev").option("-s, --https", t("dev_command_def.option.https")).option("--port <port>", t("dev_command_def.option.port"), validatePort).addOption(
+    new Option("--origin <url>", t("dev_command_def.option.origin")).argParser(validateBase).hideHelp()
+  ).action(async (options, command) => {
+    const { DevCommand } = await import("./DevCommand-47DRWF4R.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
+    const { https = false, origin, port } = options;
+    await renderCommand(
+      command,
+      services,
+      /* @__PURE__ */ import_react.default.createElement(DevCommand, { https, origin, port }),
+      {
+        watchForModelChanges: true
+      }
+    );
+  });
+};
+
+// src/commands/preview.tsx
+init_esm_shims();
+var import_react2 = __toESM(require_react(), 1);
+
+// ../cli-command-contract/src/index.ts
+init_esm_shims();
+var NO_TTY_JSON_OUTPUT_OPTION = "--json";
+
 // src/commands/preview.tsx
 var previewCommand = (services) => {
   const t = createI18nT();
@@ -3465,17 +3483,17 @@ var previewCommand = (services) => {
     ).hideHelp()
   ).action(async (options, command) => {
     const { site, baseUrl, json } = options;
-    const { renderCommand, runCommand: runCommand2 } = await import("./render-command-FI2MU2Z5.js");
+    const { renderCommand, runCommand: runCommand2 } = await import("./render-command-C6PXMRQM.js");
     if (json) {
       return runCommand2(command, services, async (model) => {
-        const { nonInteractivePreview } = await import("./preview-ZGAFDUGX.js");
+        const { nonInteractivePreview } = await import("./preview-C34XK2F7.js");
         return nonInteractivePreview(services, model, {
           baseUrl,
           siteId: site
         });
       });
     }
-    const { PreviewCommand } = await import("./PreviewCommand-YAYKKYRN.js");
+    const { PreviewCommand } = await import("./PreviewCommand-GQW2OPCK.js");
     await renderCommand(
       command,
       services,
@@ -3492,8 +3510,8 @@ var addPermissionCommand = (services) => {
   return createCommand("add-permission").description("adding a permission to the app").addOption(
     new Option("-p, --permission-id <id>", t("the permission id to add"))
   ).action(async (options, command) => {
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
-    const { AddPermissionCommand } = await import("./AddPermissionCommand-7E5GD5VD.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
+    const { AddPermissionCommand } = await import("./AddPermissionCommand-PYSE647R.js");
     const { permissionId = "" } = options;
     await renderCommand(
       command,
@@ -3509,8 +3527,8 @@ var import_react4 = __toESM(require_react(), 1);
 var serveCommand = (services) => {
   const t = createI18nT();
   return createCommand("serve").description(t("serve_command_def.description")).action(async (_, command) => {
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
-    const { ServeCommandDeprecated } = await import("./ServeCommand-NDUXIY75.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
+    const { ServeCommandDeprecated } = await import("./ServeCommand-WNAWBSEY.js");
     await renderCommand(command, services, /* @__PURE__ */ import_react4.default.createElement(ServeCommandDeprecated, null));
   });
 };
@@ -3525,8 +3543,8 @@ var generateCommand = (services) => {
     t("generate_command.type_flag"),
     validateDocsExtensionType
   ).description(t("generate_command.description")).action(async (options, command) => {
-    const { GenerateCommand } = await import("./GenerateCommand-IO6ENBOG.js");
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
+    const { GenerateCommand } = await import("./GenerateCommand-MEGRT44D.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
     const { type } = options;
     await renderCommand(
       command,
@@ -3550,8 +3568,8 @@ var logsCommand = (services) => {
     validateVersion
   ).action(async (options, command) => {
     const { version } = options;
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
-    const { LogsCommand } = await import("./LogsCommand-C62QNN65.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
+    const { LogsCommand } = await import("./LogsCommand-35KRDK3E.js");
     await renderCommand(command, services, /* @__PURE__ */ import_react6.default.createElement(LogsCommand, { version }));
   });
 };
@@ -3584,8 +3602,8 @@ var releaseCommand = (services) => {
       t("app_preview_command_def.option.json")
     ).hideHelp()
   ).action(async (options, command) => {
-    const { renderCommand } = await import("./render-command-FI2MU2Z5.js");
-    const { ReleaseCommand, ReleaseVersionType } = await import("./ReleaseCommand-77SWCHH2.js");
+    const { renderCommand } = await import("./render-command-C6PXMRQM.js");
+    const { ReleaseCommand, ReleaseVersionType } = await import("./ReleaseCommand-ALWL544L.js");
     const { baseUrl, site, comment, json } = options;
     const versionType = options.versionType ? {
       major: ReleaseVersionType.MAJOR,
@@ -3599,7 +3617,7 @@ var releaseCommand = (services) => {
     };
     if (json) {
       return runCommand(command, services, async (model) => {
-        const { nonInteractiveRelease } = await import("./release-YOEGOFAT.js");
+        const { nonInteractiveRelease } = await import("./release-EUKZ7O55.js");
         return nonInteractiveRelease(services, model, props);
       });
     }