@wix/cli 1.1.88 → 1.1.89

package/build/{chunk-LDZEOWUV.js → chunk-L6ABBZNR.js}

@@ -6,22 +6,25 @@ import {
   useARMClient,
   useUpdateDeploymentTopology,
   useUpdateManifest
-} from "./chunk-4NN2C4CS.js";
+} from "./chunk-7T7SLCFH.js";
 import {
-  useWixstroClient
-} from "./chunk-2PNYIXMP.js";
+  useHttpClient
+} from "./chunk-VCVYBKDN.js";
 import {
   buildMetadataSchema,
   getBuildManifestPath,
   useProjectModel
-} from "./chunk-AFVZOQLU.js";
+} from "./chunk-WFKMTTHE.js";
 import {
   globby
 } from "./chunk-65JTHDMM.js";
 import {
   SiteAuthProvider,
-  pLimit
-} from "./chunk-2EVNRLYY.js";
+  pLimit,
+  pRetry,
+  resolveUrl,
+  serializer
+} from "./chunk-NNJ3SLG4.js";
 import {
   Alert,
   Box_default,
@@ -29,19 +32,25 @@ import {
   Text,
   useAsync,
   useAsyncCallback
-} from "./chunk-QKHIYABF.js";
+} from "./chunk-J2QEZEUE.js";
 import {
   require_react
 } from "./chunk-SO6EZMEL.js";
+import {
+  getTestOverrides
+} from "./chunk-MWHZITF4.js";
 import {
   pathExists,
   readJson
-} from "./chunk-LPD4XGYD.js";
+} from "./chunk-JTAS7UOW.js";
+import {
+  z
+} from "./chunk-SF2XPDVG.js";
 import {
   CliError,
   CliErrorCode,
   require_lib
-} from "./chunk-ZKCONC7A.js";
+} from "./chunk-ULCE6HIP.js";
 import {
   __toESM,
   init_esm_shims
@@ -52,11 +61,11 @@ init_esm_shims();
 
 // ../cli-astro-commands/src/components/PreviewCommand/PreviewCommand.tsx
 init_esm_shims();
-var import_react3 = __toESM(require_react(), 1);
+var import_react4 = __toESM(require_react(), 1);
 
 // ../cli-astro-commands/src/components/PreviewCommand/Preview.tsx
 init_esm_shims();
-var import_react2 = __toESM(require_react(), 1);
+var import_react3 = __toESM(require_react(), 1);
 var import_variant2 = __toESM(require_lib(), 1);
 
 // ../cli-astro-commands/src/files/assert-build-output-exists.ts
@@ -136,11 +145,11 @@ function useLoadBuildFiles() {
   return useAsyncCallback(async () => {
     const buildManifest = await readBuildManifest(projectFolder);
     const client = (await loadFiles(buildManifest.clientDir)).filter(
-      ({ relativePath, path }) => {
+      ({ relativePath, path: path2 }) => {
         if (relativePath.startsWith("_wix")) {
           return false;
         }
-        if (path.startsWith(buildManifest.serverDir)) {
+        if (path2.startsWith(buildManifest.serverDir)) {
           return false;
         }
         return true;
@@ -169,8 +178,9 @@ async function loadFiles(cwd) {
   );
 }
 
-// ../cli-astro-commands/src/components/PreviewCommand/hooks/useUploadClientFiles.ts
+// ../cli-astro-commands/src/components/PreviewCommand/hooks/useDeployFiles.ts
 init_esm_shims();
+import path from "node:path";
 import crypto from "node:crypto";
 import fs from "node:fs";
 
@@ -1314,12 +1324,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path) {
-    if (typeof path !== "string")
+  getType(path2) {
+    if (typeof path2 !== "string")
       return null;
-    const last = path.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path2.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path.length;
+    const hasPath = last.length < path2.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -1359,227 +1369,347 @@ var Mime_default = Mime;
 // ../../node_modules/mime/dist/src/index.js
 var src_default = new Mime_default(standard_default, other_default)._freeze();
 
-// ../cli-astro-commands/src/components/PreviewCommand/hooks/useUploadClientFiles.ts
-function useUploadClientFiles() {
-  const {
-    model: {
-      config: { projectId }
-    }
-  } = useProjectModel();
-  const wixtro = useWixstroClient();
-  return useAsyncCallback(
-    async (_, files) => {
-      const filesWithHash = await Promise.all(
-        files.map(async (file) => {
-          const { hash, size } = await getFileMD5AndSize(file.path);
-          return { ...file, hash, size };
-        })
-      );
-      const result = await wixtro.createUploadManifest({
-        projectId,
-        manifest: Object.fromEntries(
-          filesWithHash.map(({ hash, size, relativePath }) => [
-            `/${relativePath}`,
-            { hash, size }
-          ])
-        )
-      });
-      if (result.buckets.length === 0) {
-        return {
-          deploymentToken: result.deploymentToken,
-          completionToken: result.jwt
-        };
-      }
-      const hashToFileMap = Object.fromEntries(
-        filesWithHash.map(({ hash, relativePath, path }) => [
-          hash,
-          { relativePath, path }
-        ])
-      );
-      let lastBucketResult;
-      const limit = pLimit(3);
-      const uploadPromises = result.buckets.map(
-        (bucket) => limit(async () => {
-          const bucketResult = await uploadSingleBucket(
-            result.jwt,
-            result.uploadEndpointURL,
-            bucket.map(({ serverHash, clientHash }) => {
-              const file = hashToFileMap[clientHash];
-              if (!file) {
-                throw new Error(`Unknown client file hash: ${clientHash}`);
-              }
-              return {
-                fileAbsolutePath: file.path,
-                fileHash: serverHash,
-                fileMime: src_default.getType(file.relativePath) ?? "application/octet-stream"
-              };
-            })
-          );
-          if (bucketResult) {
-            lastBucketResult = bucketResult;
-          }
-          return bucketResult;
-        })
-      );
-      await Promise.all(uploadPromises);
-      if (!lastBucketResult) {
-        throw new Error("Failed to upload assets to completion");
+// ../cli-astro-commands/src/clients/velo-backend/useVeloBackendClient.ts
+init_esm_shims();
+var import_react2 = __toESM(require_react(), 1);
+
+// ../cli-astro-commands/src/clients/velo-backend/velo-backend-client.ts
+init_esm_shims();
+
+// ../../node_modules/@wix/ambassador-velo-backend-v1-app-deployment/build/es/http.impl.js
+init_esm_shims();
+var _appDeployment = {
+  createdDate: "google.protobuf.Timestamp",
+  updatedDate: "google.protobuf.Timestamp"
+};
+var _completeAppDeploymentRequest = { appDeployment: "_appDeployment" };
+var _completeAppDeploymentResponse = { appDeployment: "_appDeployment" };
+var _createAppDeploymentRequest = { appDeployment: "_appDeployment" };
+var _createAppDeploymentResponse = { appDeployment: "_appDeployment" };
+function resolveWixVeloBackendV1AppDeploymentManagementUrl(opts) {
+  var domainToMappings = {
+    "manage._base_domain_": [
+      {
+        srcPath: "/_api/wix-code-app-deployments",
+        destPath: ""
       }
-      return {
-        completionToken: lastBucketResult,
-        deploymentToken: result.deploymentToken
-      };
-    }
-  );
+    ]
+  };
+  return resolveUrl(Object.assign(opts, { domainToMappings }));
 }
-async function getFileMD5AndSize(filePath) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto.createHash("md5");
-    const stream = fs.createReadStream(filePath);
-    let size = 0;
-    stream.on("data", (chunk) => {
-      hash.update(chunk);
-      size += chunk.length;
-    });
-    stream.on("end", () => resolve({ hash: hash.digest("hex"), size }));
-    stream.on("error", reject);
-  });
-}
-async function uploadSingleBucket(jwt, uploadEndpoint, bucket) {
-  const form = new FormData();
-  for (const file of bucket) {
-    const fileContents = await fs.promises.readFile(file.fileAbsolutePath);
-    form.append(
-      file.fileHash,
-      new File([fileContents.toString("base64")], file.fileHash, {
-        type: file.fileMime
-        // Modify Content-Type header based on type of file
+function createAppDeployment(payload) {
+  var _a = serializer(_createAppDeploymentRequest, { _appDeployment }), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_createAppDeploymentResponse, {
+    _appDeployment
+  }).fromJSON;
+  function __createAppDeployment(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.velo.backend.v1.app_deployment",
+      method: "POST",
+      methodFqn: "wix.velo.backend.v1.AppDeploymentManagement.CreateAppDeployment",
+      url: resolveWixVeloBackendV1AppDeploymentManagementUrl({
+        protoPath: "/v1/app-projects/{appDeployment.appProjectId}/app-deployments",
+        data: serializedData,
+        host
       }),
-      file.fileHash
-    );
-  }
-  const response = await fetch(uploadEndpoint, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${jwt}`
-    },
-    body: form
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Failed to upload bucket: ${response.status} - ${response.statusText} ${await response.text()}`
-    );
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
   }
-  const data = await response.json();
-  if (data.result.jwt) {
-    return data.result.jwt;
+  __createAppDeployment.fromReq = fromReq;
+  __createAppDeployment.__isAmbassador = true;
+  return __createAppDeployment;
+}
+function completeAppDeployment(payload) {
+  var _a = serializer(_completeAppDeploymentRequest, { _appDeployment }), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_completeAppDeploymentResponse, {
+    _appDeployment
+  }).fromJSON;
+  function __completeAppDeployment(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.velo.backend.v1.app_deployment",
+      method: "POST",
+      methodFqn: "wix.velo.backend.v1.AppDeploymentManagement.CompleteAppDeployment",
+      url: resolveWixVeloBackendV1AppDeploymentManagementUrl({
+        protoPath: "/v1/app-projects/{appDeployment.appProjectId}/app-deployments/{appDeployment.id}/complete",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
   }
+  __completeAppDeployment.fromReq = fromReq;
+  __completeAppDeployment.__isAmbassador = true;
+  return __completeAppDeployment;
 }
 
-// ../cli-astro-commands/src/components/PreviewCommand/hooks/useUploadServerFiles.ts
+// ../cli-astro-commands/src/clients/velo-backend/schemas.ts
 init_esm_shims();
-import fs2 from "node:fs/promises";
-function useUploadServerFiles() {
+var staticFileMetadata = z.object({
+  path: z.string(),
+  hash: z.string(),
+  size: z.number().optional(),
+  contentType: z.string().optional().nullable()
+});
+var StaticFileUploadUrlSchema = z.object({
+  uploadUrl: z.string().url(),
+  staticFileMetadata
+});
+var AppDeploymentSchema = z.object({
+  id: z.string().uuid(),
+  deploymentBaseUrl: z.string()
+}).passthrough();
+var CompleteAppDeploymentSchema = z.object({
+  appDeployment: AppDeploymentSchema
+});
+var CreateAppDeploymentSchema = z.object({
+  staticFilesUploadUrls: z.array(StaticFileUploadUrlSchema).optional(),
+  uploadAuthToken: z.string(),
+  appDeployment: AppDeploymentSchema.optional()
+});
+var StaticFileUploadSchema = z.object({
+  result: z.object({
+    jwt: z.string()
+  })
+}).passthrough();
+
+// ../cli-astro-commands/src/clients/velo-backend/velo-backend-client.ts
+var { minRetryTimeout } = getTestOverrides();
+var VeloBackendClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    this.retryOptions = {
+      retries: 3,
+      minTimeout: minRetryTimeout,
+      maxTimeout: 3 * 1e3
+    };
+  }
+  retryOptions;
+  createAppDeployment = async (appId, staticFilesMetadata) => {
+    try {
+      const { data } = await pRetry(
+        () => this.httpClient.request(
+          createAppDeployment({
+            appDeployment: {
+              appProjectId: appId,
+              staticFilesMetadata
+            }
+          })
+        ),
+        this.retryOptions
+      );
+      return CreateAppDeploymentSchema.parse(data);
+    } catch (e) {
+      throw new CliError({
+        code: CliErrorCode.FailedCreatingAppDeployment(),
+        cause: e
+      });
+    }
+  };
+  completeAppDeployment = async (appDeployment, staticsCompletionToken) => {
+    try {
+      const { data } = await pRetry(
+        () => this.httpClient.request(
+          completeAppDeployment({
+            appDeployment,
+            staticsCompletionToken
+          })
+        ),
+        this.retryOptions
+      );
+      return CompleteAppDeploymentSchema.parse(data).appDeployment;
+    } catch (e) {
+      throw new CliError({
+        code: CliErrorCode.FailedFinalizingAppDeployment(),
+        cause: e
+      });
+    }
+  };
+  postForm = async (endpointUrl, token, formData) => {
+    try {
+      const responseJson = await pRetry(
+        async () => {
+          const response = await fetch(endpointUrl, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${token}`
+            },
+            body: formData
+          });
+          if (!response.ok) {
+            throw new Error(response.statusText);
+          }
+          return response.json();
+        },
+        { retries: 3 }
+      );
+      return StaticFileUploadSchema.parse(responseJson);
+    } catch (e) {
+      throw new CliError({
+        code: CliErrorCode.FailedToUploadStaticFiles(),
+        cause: e
+      });
+    }
+  };
+};
+
+// ../cli-astro-commands/src/clients/velo-backend/useVeloBackendClient.ts
+function useVeloBackendClient() {
+  const httpClient = useHttpClient({ type: "backoffice" });
+  return (0, import_react2.useMemo)(() => new VeloBackendClient(httpClient), [httpClient]);
+}
+
+// ../cli-astro-commands/src/components/PreviewCommand/hooks/useDeployFiles.ts
+function useDeployFiles() {
   const {
     model: {
-      config: { projectId }
+      projectFolder,
+      config: { appId }
     }
   } = useProjectModel();
-  const wixstroClient = useWixstroClient();
-  return useAsyncCallback(
-    async (_, files, tokens, environment) => {
-      const toBlob = (buffer, mimeType) => new Blob([buffer], { type: mimeType });
-      const filesWithBuffer = await Promise.all(
-        files.map(async (file) => {
-          const buffer = await fs2.readFile(file.path);
-          return { ...file, buffer };
-        })
-      );
-      const formData = new FormData();
-      const metadataBlob = new Blob(
-        [
-          JSON.stringify({
-            environment,
-            deploymentToken: tokens.deploymentToken,
-            jwtCompletionToken: tokens.completionToken
-          })
-        ],
-        { type: "application/json" }
+  const veloBackendClient = useVeloBackendClient();
+  return useAsyncCallback(async (_, files) => {
+    const clientFilesMetadata = await Promise.all(
+      files.client.map(getStaticFileMetadata)
+    );
+    const { appDeployment, staticFilesUploadUrls, uploadAuthToken } = await veloBackendClient.createAppDeployment(appId, clientFilesMetadata);
+    const uploadLimiter = pLimit(3);
+    let lastUploadAuthToken = uploadAuthToken;
+    if (staticFilesUploadUrls?.length && lastUploadAuthToken) {
+      const uploadPromises = staticFilesUploadUrls.map(
+        ({ uploadUrl, staticFileMetadata: staticFileMetadata2 }) => {
+          return uploadLimiter(async () => {
+            const formData = await buildFormData(
+              projectFolder,
+              staticFileMetadata2
+            );
+            const {
+              result: { jwt: responseUploadToken }
+            } = await veloBackendClient.postForm(
+              uploadUrl,
+              lastUploadAuthToken,
+              formData
+            );
+            if (responseUploadToken) {
+              lastUploadAuthToken = responseUploadToken;
+            }
+            return responseUploadToken;
+          });
+        }
       );
-      formData.append("metadata", metadataBlob);
-      for (const file of filesWithBuffer) {
-        formData.append(
-          `worker/${file.relativePath}`,
-          toBlob(
-            file.buffer,
-            src_default.getType(file.path) ?? "application/octet-stream"
-          )
-        );
-      }
-      const deployResult = await wixstroClient.deployV2({
-        projectId,
-        formData
-      });
-      return deployResult;
+      await Promise.all(uploadPromises);
     }
+    const backendFiles = await Promise.all(
+      files.server.map(getBackendFileData)
+    );
+    const completeAppDeployment2 = await veloBackendClient.completeAppDeployment(
+      {
+        ...appDeployment,
+        files: backendFiles
+      },
+      lastUploadAuthToken
+    );
+    return {
+      deploymentId: completeAppDeployment2.id,
+      deploymentBaseUrl: completeAppDeployment2.deploymentBaseUrl
+    };
+  });
+}
+async function getStaticFileMetadata(file) {
+  const stats = await fs.promises.stat(file.path);
+  const fileContent = await fs.promises.readFile(file.path);
+  const hash = crypto.createHash("md5").update(fileContent).digest("hex");
+  return {
+    size: stats.size,
+    hash,
+    contentType: src_default.getType(file.path),
+    path: `/${file.relativePath}`
+  };
+}
+async function getBackendFileData(file) {
+  const buffer = await fs.promises.readFile(file.path);
+  return { path: file.relativePath, content: buffer.toString("base64") };
+}
+async function buildFormData(projectFolder, staticFileMetadata2) {
+  const form = new FormData();
+  const fileContents = await fs.promises.readFile(
+    path.join(projectFolder, "dist", staticFileMetadata2.path)
+  );
+  form.append(
+    staticFileMetadata2.hash,
+    new File([fileContents.toString("base64")], staticFileMetadata2.hash, {
+      type: staticFileMetadata2.contentType
+    }),
+    staticFileMetadata2.hash
   );
+  return form;
 }
 
 // ../cli-astro-commands/src/components/PreviewCommand/Preview.tsx
 var Preview = ({ environment, baseUrl, onPreviewCreated }) => {
   const { model } = useProjectModel();
-  const arm = useARMClient();
+  const armClient = useARMClient();
   const loadBuildFiles = useLoadBuildFiles();
-  const uploadClientFiles = useUploadClientFiles();
-  const uploadServerFiles = useUploadServerFiles();
+  const deployFiles = useDeployFiles();
   const updateDeploymentTopology = useUpdateDeploymentTopology();
-  const updateManifest = useUpdateManifest();
+  const { updateManifest, updateManifestWithBackendWorker } = useUpdateManifest();
   const uploadApplicationAction = useAsyncCallback(
     async (_, baseUrl2) => {
       const buildFiles = await loadBuildFiles.execute();
-      const { deploymentToken, completionToken } = await uploadClientFiles.execute(buildFiles.client);
-      const result = await uploadServerFiles.execute(
-        buildFiles.server,
-        { deploymentToken, completionToken },
-        environment
-      );
-      return baseUrl2 ?? `https://${result.domain}/`;
+      const { deploymentBaseUrl, deploymentId } = await deployFiles.execute(buildFiles);
+      return {
+        deploymentUrl: baseUrl2 ?? deploymentBaseUrl,
+        deploymentId
+      };
     }
   );
   const createPreviewTagAction = useAsyncCallback(
-    async (_, serverUrl) => {
+    async (_, serverUrl, deploymentId) => {
       const manifest = await readAppManifestFile(model.projectFolder);
-      const updatedManifest = updateManifest(manifest, serverUrl);
-      return arm.createAppRelease(updatedManifest, model.config.projectId);
+      const updatedManifest = updateManifest(
+        updateManifestWithBackendWorker(manifest, deploymentId),
+        serverUrl
+      );
+      return armClient.createAppRelease(updatedManifest, model.config.appId);
     }
   );
   const { status: createPreviewStatus } = useAsync(async () => {
     await assertBuildOutputExists(model.projectFolder);
-    const serverUrl = await uploadApplicationAction.execute(baseUrl);
-    const armTag = await createPreviewTagAction.execute(serverUrl);
+    const { deploymentUrl: depoymentUrl, deploymentId } = await uploadApplicationAction.execute(baseUrl);
+    const armTag = await createPreviewTagAction.execute(
+      depoymentUrl,
+      deploymentId
+    );
     await updateDeploymentTopology.execute({
-      serverUrl,
+      serverUrl: depoymentUrl,
       armTag,
       environment
     });
-    onPreviewCreated?.({ armTag, serverUrl });
-    return { armTag, serverUrl };
+    onPreviewCreated?.({ armTag, serverUrl: depoymentUrl });
+    return { armTag, depoymentUrl };
   }, []);
-  return /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null, /* @__PURE__ */ import_react2.default.createElement(
+  return /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(
     ActionStatus,
     {
       status: uploadApplicationAction.status,
       loadingText: "Uploading your application files...",
       successText: "Uploaded successfully!"
     }
-  ), /* @__PURE__ */ import_react2.default.createElement(
+  ), /* @__PURE__ */ import_react3.default.createElement(
     ActionStatus,
     {
       status: createPreviewTagAction.status,
       loadingText: "Creating a preview...",
       successText: "Preview created successfully!"
     }
-  ), /* @__PURE__ */ import_react2.default.createElement(
+  ), /* @__PURE__ */ import_react3.default.createElement(
     ActionStatus,
     {
       status: updateDeploymentTopology.status,
@@ -1589,7 +1719,7 @@ var Preview = ({ environment, baseUrl, onPreviewCreated }) => {
   ), (0, import_variant2.match)(createPreviewStatus, {
     Error: () => null,
     Loading: () => null,
-    Success: ({ result: { armTag, serverUrl } }) => /* @__PURE__ */ import_react2.default.createElement(Box_default, { rowGap: 1, marginY: 1, flexDirection: "column" }, /* @__PURE__ */ import_react2.default.createElement(Text, null, "Open the preview on:"), /* @__PURE__ */ import_react2.default.createElement(Box_default, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ import_react2.default.createElement(PlatformLink, { url: serverUrl, label: "Site" }), /* @__PURE__ */ import_react2.default.createElement(
+    Success: ({ result: { armTag, depoymentUrl } }) => /* @__PURE__ */ import_react3.default.createElement(Box_default, { rowGap: 1, marginY: 1, flexDirection: "column" }, /* @__PURE__ */ import_react3.default.createElement(Text, null, "Open the preview on:"), /* @__PURE__ */ import_react3.default.createElement(Box_default, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ import_react3.default.createElement(PlatformLink, { url: depoymentUrl, label: "Site" }), /* @__PURE__ */ import_react3.default.createElement(
       PlatformLink,
       {
         url: `https://manage.wix.com/dashboard/${model.config.siteId}?apps-override=${armTag}`,
@@ -1606,7 +1736,7 @@ var PreviewCommand = ({ environment, baseUrl, onPreviewCreated }) => {
       config: { siteId }
     }
   } = useProjectModel();
-  return /* @__PURE__ */ import_react3.default.createElement(SiteAuthProvider, { siteId }, /* @__PURE__ */ import_react3.default.createElement(
+  return /* @__PURE__ */ import_react4.default.createElement(SiteAuthProvider, { siteId }, /* @__PURE__ */ import_react4.default.createElement(
     Preview,
     {
       baseUrl,
@@ -1620,4 +1750,4 @@ export {
   assertBuildOutputExists,
   PreviewCommand
 };
-//# sourceMappingURL=chunk-LDZEOWUV.js.map
+//# sourceMappingURL=chunk-L6ABBZNR.js.map