@base44-preview/cli 0.1.7-pr.585.818cbdc → 0.1.7-pr.585.8ca1ebb

package/dist/cli/index.js

@@ -248113,6 +248113,7 @@ var package_default = {
     nanoid: "^5.1.6",
     open: "^11.0.0",
     outdent: "^0.8.0",
+    "p-map": "^7.0.6",
     "p-wait-for": "^6.0.0",
     "posthog-node": "5.21.2",
     qs: "^6.12.3",
@@ -248361,12 +248362,6 @@ async function createArchive(pathToArchive, targetArchivePath) {
     cwd: pathToArchive
   }, ["."]);
 }
-// src/core/site/gate.ts
-var STATIC_DEPLOYMENTS_ENV = "BASE44_STATIC_DEPLOYMENTS";
-function staticDeploymentsEnabled(env2 = process.env) {
-  const value = env2[STATIC_DEPLOYMENTS_ENV];
-  return value === "1" || value === "true";
-}
 // src/core/site/manifest.ts
 import { createHash } from "node:crypto";
 import { readFile as readFile2, stat } from "node:fs/promises";
@@ -248415,66 +248410,172 @@ async function buildAssetManifest(assetsDir, appId) {
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 
-// src/core/utils/git.ts
-var GIT_HASH_PATTERN = /^[a-fA-F0-9]{7,64}$/;
-function isGitCommitHash(value) {
-  return GIT_HASH_PATTERN.test(value);
+// src/core/site/upload.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// ../../node_modules/p-map/index.js
+async function pMap(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  stopOnError = true,
+  signal
+} = {}) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+    }
+    if (typeof mapper !== "function") {
+      throw new TypeError("Mapper function is required");
+    }
+    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+    }
+    const result = [];
+    const errors4 = [];
+    const skippedIndexesMap = new Map;
+    let isRejected = false;
+    let isResolved = false;
+    let isIterableDone = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    const signalListener = () => {
+      reject(signal.reason);
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", signalListener);
+    };
+    const resolve3 = (value) => {
+      resolve_(value);
+      cleanup();
+    };
+    const reject = (reason) => {
+      isRejected = true;
+      isResolved = true;
+      reject_(reason);
+      cleanup();
+    };
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason);
+        return;
+      }
+      signal.addEventListener("abort", signalListener, { once: true });
+    }
+    const next = async () => {
+      if (isResolved) {
+        return;
+      }
+      const nextItem = await iterator.next();
+      const index = currentIndex;
+      currentIndex++;
+      if (nextItem.done) {
+        isIterableDone = true;
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors4.length > 0) {
+            reject(new AggregateError(errors4));
+            return;
+          }
+          isResolved = true;
+          if (skippedIndexesMap.size === 0) {
+            resolve3(result);
+            return;
+          }
+          const pureResult = [];
+          for (const [index2, value] of result.entries()) {
+            if (skippedIndexesMap.get(index2) === pMapSkip) {
+              continue;
+            }
+            pureResult.push(value);
+          }
+          resolve3(pureResult);
+        }
+        return;
+      }
+      resolvingCount++;
+      (async () => {
+        try {
+          const element = await nextItem.value;
+          if (isResolved) {
+            return;
+          }
+          const value = await mapper(element, index);
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error48) {
+          if (stopOnError) {
+            reject(error48);
+          } else {
+            errors4.push(error48);
+            resolvingCount--;
+            try {
+              await next();
+            } catch (error49) {
+              reject(error49);
+            }
+          }
+        }
+      })();
+    };
+    (async () => {
+      for (let index = 0;index < concurrency; index++) {
+        try {
+          await next();
+        } catch (error48) {
+          reject(error48);
+          break;
+        }
+        if (isIterableDone || isRejected) {
+          break;
+        }
+      }
+    })();
+  });
 }
+var pMapSkip = Symbol("skip");
 
 // src/core/site/upload.ts
-import { readFile as readFile3 } from "node:fs/promises";
-var UPLOAD_CONCURRENCY = 3;
-var MAX_ATTEMPTS_PER_UPLOAD = 3;
+var DEFAULT_UPLOAD_CONCURRENCY = 3;
+var MAX_UPLOAD_CONCURRENCY = 50;
+var MAX_UPLOAD_ATTEMPTS = 3;
 var RETRY_BASE_DELAY_MS = 500;
-async function uploadPresignedAssets(uploads, assets, onProgress) {
+async function uploadPresignedAssets(uploads, assets, options = {}) {
+  const { concurrency = DEFAULT_UPLOAD_CONCURRENCY, onProgress } = options;
   let uploadedFiles = 0;
-  let nextUpload = 0;
-  const worker = async () => {
-    while (nextUpload < uploads.length) {
-      const upload = uploads[nextUpload++];
-      await uploadPresignedAssetWithRetry(upload, assets);
-      uploadedFiles++;
-      onProgress?.({ uploadedFiles, totalFiles: uploads.length });
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(UPLOAD_CONCURRENCY, uploads.length) }, worker));
+  await pMap(uploads, async (upload) => {
+    await uploadPresignedAsset(upload, assets);
+    uploadedFiles++;
+    onProgress?.({ uploadedFiles, totalFiles: uploads.length });
+  }, { concurrency });
 }
-async function uploadPresignedAssetWithRetry(upload, assets) {
+async function uploadPresignedAsset(upload, assets) {
   const entry = assets.manifest[upload.path];
   const file2 = entry && assets.filesByHash.get(entry.hash);
   if (!file2) {
     throw new InternalError(`Server requested upload of unknown asset path: ${upload.path}`);
   }
   const content = await readFile3(file2.absolutePath);
-  let lastError;
-  for (let attempt = 0;attempt < MAX_ATTEMPTS_PER_UPLOAD; attempt++) {
-    if (attempt > 0) {
-      await sleep3(RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
-    }
-    try {
-      await distribution_default.put(upload.url, {
-        body: new Uint8Array(content),
-        headers: { "Content-Type": upload.contentType },
-        timeout: 120000,
-        retry: 0
-      });
-      return;
-    } catch (error48) {
-      lastError = error48;
-    }
+  try {
+    await distribution_default.put(upload.url, {
+      body: new Uint8Array(content),
+      headers: { "Content-Type": upload.contentType },
+      timeout: 120000,
+      retry: {
+        limit: MAX_UPLOAD_ATTEMPTS - 1,
+        delay: (attempt) => RETRY_BASE_DELAY_MS * 2 ** (attempt - 1)
+      }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "uploading static assets");
   }
-  throw await ApiError.fromHttpError(lastError, "uploading static assets");
-}
-function sleep3(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/core/site/static-site.ts
 async function deployStaticSite(options) {
-  const { outputDir, gitHash, progress } = options;
-  if (!isGitCommitHash(gitHash)) {
-    throw new InvalidInputError(`'${gitHash}' is not a git commit hash.`);
-  }
+  const { outputDir, gitHash, concurrency, progress } = options;
   const assets = await buildAssetManifest(outputDir, getAppContext().id);
   if (!assets.manifest["/index.html"]) {
     throw new InvalidInputError(`No index.html found in "${outputDir}" — a static site needs one at the output directory root.`);
@@ -248488,7 +248589,10 @@ async function deployStaticSite(options) {
     newAssets: created.assetUploads?.uploads.length ?? 0
   });
   if (created.assetUploads) {
-    await uploadPresignedAssets(created.assetUploads.uploads, assets, progress?.onAssetUpload);
+    await uploadPresignedAssets(created.assetUploads.uploads, assets, {
+      concurrency,
+      onProgress: progress?.onAssetUpload
+    });
   }
   const indexHtml = await readFile4(join16(outputDir, "index.html"));
   const finalized = await finalizeStaticDeployment(created.deploymentId, new Uint8Array(indexHtml));
@@ -255716,6 +255820,11 @@ function verifyDenoInstalled(context) {
     });
   }
 }
+// src/core/utils/git.ts
+var GIT_HASH_PATTERN = /^[a-fA-F0-9]{7,64}$/;
+function isGitCommitHash(value) {
+  return GIT_HASH_PATTERN.test(value);
+}
 // src/core/workspace/schema.ts
 var WorkspaceSchema = exports_external.object({
   id: exports_external.string(),
@@ -258940,13 +259049,15 @@ async function deployAction2(ctx, options) {
   }
   await maybeBuildBeforeDeploy(ctx, project2, options.build);
   const outputDir = resolve11(project2.root, outputDirectory);
-  return options.gitHash ? await deployToDeploymentsApi(ctx, outputDir, options.gitHash) : await deployTarball(ctx, outputDir);
+  const { gitHash, concurrency } = options;
+  return gitHash ? await deployToDeploymentsApi(ctx, outputDir, gitHash, concurrency) : await deployTarball(ctx, outputDir);
 }
-async function deployToDeploymentsApi({ runTask: runTask2, log, jsonMode }, outputDir, gitHash) {
+async function deployToDeploymentsApi({ runTask: runTask2, log, jsonMode }, outputDir, gitHash, concurrency) {
   const progressLines = [];
   const { deploymentId } = await runTask2("Deploying site...", async (updateMessage) => await deployStaticSite({
     outputDir,
     gitHash,
+    concurrency,
     progress: {
       onAssets: ({ totalAssets, newAssets }) => {
         const line = `Found ${totalAssets} static assets (${newAssets} new)`;
@@ -258977,10 +259088,27 @@ async function deployTarball({ runTask: runTask2 }, outputDir) {
 function getSiteDeployCommand() {
   const command2 = new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)");
   if (staticDeploymentsEnabled()) {
-    command2.addOption(new Option("--git-hash <hash>", "Commit the build came from — deploys through the deployments API"));
+    command2.addOption(new Option("--git-hash <hash>", "Commit the build came from — deploys through the deployments API").argParser((value) => {
+      if (!isGitCommitHash(value)) {
+        throw new InvalidArgumentError("Expected a git commit hash (7-64 hex chars).");
+      }
+      return value;
+    }));
+    command2.addOption(new Option("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency));
   }
   return command2.action(deployAction2);
 }
+function parseConcurrency(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_UPLOAD_CONCURRENCY) {
+    throw new InvalidArgumentError(`Expected a whole number between 1 and ${MAX_UPLOAD_CONCURRENCY}.`);
+  }
+  return parsed;
+}
+function staticDeploymentsEnabled(env3 = process.env) {
+  const value = env3["BASE44_STATIC_DEPLOYMENTS"];
+  return value === "1" || value === "true";
+}
 
 // src/cli/commands/site/open.ts
 async function openAction({
@@ -267773,4 +267901,4 @@ export {
   CLIExitError
 };
 
-//# debugId=7E09388401C6A22064756E2164756E21
+//# debugId=93B51FE0D9C7A0D764756E2164756E21