tiendu 0.3.1 → 0.5.0

package/lib/dev.mjs

@@ -1,10 +1,10 @@
 import { watch } from "node:fs";
-import { readFile, readdir, stat } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import * as p from "@clack/prompts";
-import { zipSync } from "fflate";
 import { loadConfigOrFail, writeConfig, isBuiltTheme, getDistDir } from "./config.mjs";
 import {
+  buildPreviewUrl,
   createPreview,
   listPreviews,
   resolveActivePreview,
@@ -12,45 +12,100 @@ import {
 import {
   deletePreviewFile,
   uploadPreviewFileMultipart,
-  uploadPreviewZip,
 } from "./api.mjs";
 import { build } from "./build.mjs";
+import { isDotfile } from "./fs-utils.mjs";
+import { startLocalPreviewServer } from "./local-preview.mjs";
+import { pushPreparedDirectoryToPreview } from "./push.mjs";
+import { retryAsync } from "./retry.mjs";
 
-const isDotfile = (name) => name.startsWith(".");
-
-const buildPreviewUrl = (apiBaseUrl, previewHostname) => {
-  const base = new URL(apiBaseUrl);
-  const hasExplicitPort = previewHostname.includes(":");
-  return `${base.protocol}//${previewHostname}${!hasExplicitPort && base.port ? `:${base.port}` : ""}/`;
-};
+const RETRY_ATTEMPTS = 3;
+const MAX_SYNC_FILE_SIZE_BYTES = 20 * 1024 * 1024;
+const IGNORED_ROOT_SEGMENTS = new Set(["node_modules", ".git"]);
 
 const hasDotfileSegment = (relativePath) =>
   relativePath.split(path.sep).some(isDotfile);
 
-const listAllFiles = async (rootDir, currentDir) => {
-  const entries = await readdir(currentDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    if (isDotfile(entry.name)) continue;
-    const abs = path.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...(await listAllFiles(rootDir, abs)));
-    } else if (entry.isFile()) {
-      files.push(abs);
-    }
+const shouldIgnoreWatchedPath = (relativePath, builtTheme) => {
+  const normalizedPath = relativePath.split(path.sep).join("/");
+  const segments = normalizedPath.split("/");
+  const basename = segments.at(-1) ?? "";
+
+  if (segments.some((segment) => IGNORED_ROOT_SEGMENTS.has(segment))) {
+    return true;
+  }
+
+  if (!builtTheme && segments[0] === "dist") {
+    return true;
   }
-  return files;
+
+  return basename.endsWith("~") || /\.(swp|tmp|temp)$/i.test(basename);
 };
 
-const createZipFromDirectory = async (rootDir) => {
-  const absoluteFiles = await listAllFiles(rootDir, rootDir);
-  /** @type {Record<string, Uint8Array>} */
-  const entries = {};
-  for (const abs of absoluteFiles) {
-    const rel = path.relative(rootDir, abs).split(path.sep).join("/");
-    entries[rel] = new Uint8Array(await readFile(abs));
+const shouldRetrySyncResult = (result) =>
+  !result.ok && Boolean(result.retriable);
+
+const uploadFileWithRetries = (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  relativePath,
+  content,
+  onRetry,
+) =>
+  retryAsync(
+    () =>
+      uploadPreviewFileMultipart(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+        content,
+      ),
+    {
+      attempts: RETRY_ATTEMPTS,
+      shouldRetry: shouldRetrySyncResult,
+      onRetry,
+    },
+  );
+
+const deleteFileWithRetries = (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  relativePath,
+  onRetry,
+) =>
+  retryAsync(
+    () =>
+      deletePreviewFile(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+      ),
+    {
+      attempts: RETRY_ATTEMPTS,
+      shouldRetry: shouldRetrySyncResult,
+      onRetry,
+    },
+  );
+
+const resolvePreviewForDev = (previews, configuredPreviewKey) => {
+  const activePreview = resolveActivePreview(previews, configuredPreviewKey);
+  if (activePreview) {
+    return { preview: activePreview, fallbackUsed: false };
+  }
+
+  if (configuredPreviewKey && previews.length === 1) {
+    return { preview: previews[0], fallbackUsed: true };
   }
-  return Buffer.from(zipSync(entries, { level: 6 }));
+
+  return { preview: null, fallbackUsed: false };
 };
 
 export const dev = async () => {
@@ -60,6 +115,7 @@ export const dev = async () => {
   const builtTheme = await isBuiltTheme();
   const rootDir = builtTheme ? getDistDir() : process.cwd();
   let buildCleanup = null;
+  let localPreviewServer = null;
 
   // For built themes, run the build first (with watch mode)
   if (builtTheme) {
@@ -71,150 +127,197 @@ export const dev = async () => {
     buildCleanup = buildResult.cleanup;
   }
 
-  const existingPreviewsResult = await listPreviews(
-    apiBaseUrl,
-    apiKey,
-    storeId,
-  );
-  if (!existingPreviewsResult.ok) {
-    p.log.error(existingPreviewsResult.error);
+  const spinner = p.spinner();
+  spinner.start("Connecting to preview...");
+
+  const listResult = await listPreviews(apiBaseUrl, apiKey, storeId);
+  if (!listResult.ok) {
+    spinner.stop("Failed to connect.", 1);
+    p.log.error(listResult.error);
     process.exit(1);
   }
 
-  let previewKey =
-    resolveActivePreview(existingPreviewsResult.data, config.previewKey)
-      ?.previewKey ?? config.previewKey;
-  let previewUrl;
+  const previewResolution = resolvePreviewForDev(listResult.data, config.previewKey);
+  let activePreview = previewResolution.preview;
+  if (previewResolution.fallbackUsed && activePreview) {
+    p.log.warn(
+      `Stored preview ${config.previewKey} was not found. Using the only available preview ${activePreview.previewKey}.`,
+    );
+  }
 
-  if (!previewKey) {
-    // ── Create preview and do initial upload ─────────────────────────────────
-    const spinner = p.spinner();
-    spinner.start("No active preview found. Creating one...");
+  if (!activePreview) {
+    if (config.previewKey) {
+      p.log.warn(
+        `Stored preview ${config.previewKey} was not found. Creating a new preview...`,
+      );
+    }
 
-    const result = await createPreview(apiBaseUrl, apiKey, storeId, "Dev");
-    if (!result.ok) {
+    spinner.message("Creating preview...");
+    const previewResult = await createPreview(apiBaseUrl, apiKey, storeId, "Dev");
+    if (!previewResult.ok) {
       spinner.stop("Failed to create preview.", 1);
-      p.log.error(result.error);
+      p.log.error(previewResult.error);
       process.exit(1);
     }
 
-    previewKey = result.data.previewKey;
-    previewUrl = buildPreviewUrl(apiBaseUrl, result.data.previewHostname);
-    await writeConfig({ ...config, previewKey });
-
-    spinner.message("Uploading initial files...");
-    const zipBuffer = await createZipFromDirectory(rootDir);
-    const uploadResult = await uploadPreviewZip(
-      apiBaseUrl,
-      apiKey,
-      storeId,
-      previewKey,
-      zipBuffer,
-    );
+    activePreview = previewResult.data;
+  }
 
-    if (!uploadResult.ok) {
-      spinner.stop("Failed to upload files.", 1);
-      p.log.error(uploadResult.error);
-      process.exit(1);
-    }
+  const previewKey = activePreview.previewKey;
+  if (config.previewKey !== previewKey) {
+    await writeConfig({ ...config, previewKey });
+  }
 
-    spinner.stop(`Preview ready: ${previewUrl}`);
-  } else {
-    // ── Verify existing preview still exists ─────────────────────────────────
-    const spinner = p.spinner();
-    spinner.start("Connecting to preview...");
+  const previewUrl = buildPreviewUrl(apiBaseUrl, activePreview.previewHostname);
 
-    const listResult = await listPreviews(apiBaseUrl, apiKey, storeId);
-    if (!listResult.ok) {
-      spinner.stop("Failed to connect.", 1);
-      p.log.error(listResult.error);
-      process.exit(1);
-    }
+  const uploadResult = await pushPreparedDirectoryToPreview({
+    apiBaseUrl,
+    apiKey,
+    storeId,
+    previewKey,
+    rootDir,
+    spinner,
+    packMessage: "Running initial push...",
+    retryMessage: (result, nextAttempt) =>
+      `Initial push failed. Retrying ${nextAttempt}/${RETRY_ATTEMPTS}... ${result.error}`,
+  });
 
-    const existing = resolveActivePreview(listResult.data, previewKey);
-    if (!existing) {
-      spinner.stop("Could not determine the active preview.", 1);
-      p.log.error(
-        listResult.data.length === 0
-          ? "No previews found for this store. A new preview will be created if you clear the local config and run tiendu dev again."
-          : "Run tiendu preview list and then set or recreate the preview.",
-      );
-      process.exit(1);
-    }
+  if (!uploadResult.ok) {
+    spinner.stop("Initial push failed.", 1);
+    p.log.error(uploadResult.error);
+    process.exit(1);
+  }
 
-    previewKey = existing.previewKey;
-    if (config.previewKey !== previewKey) {
-      await writeConfig({ ...config, previewKey });
-    }
+  try {
+    localPreviewServer = await startLocalPreviewServer({
+      apiBaseUrl,
+      previewHostname: activePreview.previewHostname,
+    });
+  } catch (error) {
+    p.log.warn(`Could not start local live preview: ${error.message}`);
+  }
 
-    previewUrl = buildPreviewUrl(apiBaseUrl, existing.previewHostname);
-    spinner.stop(`Preview: ${previewUrl}`);
+  spinner.stop("Preview ready.");
+  if (localPreviewServer) {
+    p.log.message(`Local live preview: ${localPreviewServer.url}`);
   }
+  p.log.message(`Sharable preview: ${previewUrl}`);
 
   p.log.message("Watching for changes — press Ctrl+C to stop.");
 
   // ── File watcher ──────────────────────────────────────────────────────────
   /** @type {Map<string, NodeJS.Timeout>} */
   const debounceMap = new Map();
+  const inFlightPaths = new Set();
+  const pendingResyncPaths = new Set();
   const DEBOUNCE_MS = 300;
 
-  const watcher = watch(rootDir, { recursive: true }, (eventType, filename) => {
-    if (!filename) return;
-    if (hasDotfileSegment(filename)) return;
-
-    const relativePath = filename.split(path.sep).join("/");
-    const existing = debounceMap.get(relativePath);
-    if (existing) clearTimeout(existing);
+  const queueSync = (relativePath) => {
+    const existingTimer = debounceMap.get(relativePath);
+    if (existingTimer) clearTimeout(existingTimer);
 
-    const timer = setTimeout(async () => {
+    const timer = setTimeout(() => {
       debounceMap.delete(relativePath);
-      const absolutePath = path.join(rootDir, filename);
-
-      try {
-        const fileStat = await stat(absolutePath).catch(() => null);
-
-        if (!fileStat || !fileStat.isFile()) {
-          if (!fileStat) {
-            console.log(`✕ ${relativePath}`);
-            const result = await deletePreviewFile(
-              apiBaseUrl,
-              apiKey,
-              storeId,
-              previewKey,
-              relativePath,
-            );
-            if (!result.ok) {
-              p.log.warn(`     Failed to delete: ${result.error}`);
-            }
+      void syncPath(relativePath);
+    }, DEBOUNCE_MS);
+
+    debounceMap.set(relativePath, timer);
+  };
+
+  const syncPath = async (relativePath) => {
+    if (inFlightPaths.has(relativePath)) {
+      pendingResyncPaths.add(relativePath);
+      return;
+    }
+
+    inFlightPaths.add(relativePath);
+
+    try {
+      const absolutePath = path.join(rootDir, relativePath);
+      const fileStat = await stat(absolutePath).catch(() => null);
+
+      if (!fileStat || !fileStat.isFile()) {
+        if (!fileStat) {
+          console.log(`✕ ${relativePath}`);
+          const result = await deleteFileWithRetries(
+            apiBaseUrl,
+            apiKey,
+            storeId,
+            previewKey,
+            relativePath,
+            async (_, nextAttempt) => {
+              p.log.warn(
+                `     Retry delete ${relativePath} (${nextAttempt}/${RETRY_ATTEMPTS})`,
+              );
+            },
+          );
+
+          if (!result.ok) {
+            p.log.warn(`     Failed to delete after ${RETRY_ATTEMPTS} attempts: ${result.error}`);
+          } else {
+            localPreviewServer?.notifyReload();
           }
-          return;
         }
 
-        console.log(`↑ ${relativePath}`);
-        const content = await readFile(absolutePath);
-        const result = await uploadPreviewFileMultipart(
-          apiBaseUrl,
-          apiKey,
-          storeId,
-          previewKey,
-          relativePath,
-          content,
+        return;
+      }
+
+      console.log(`↑ ${relativePath}`);
+      if (fileStat.size > MAX_SYNC_FILE_SIZE_BYTES) {
+        p.log.warn(
+          `     Skipping ${relativePath}: file is ${(fileStat.size / (1024 * 1024)).toFixed(1)} MB (limit ${(MAX_SYNC_FILE_SIZE_BYTES / (1024 * 1024)).toFixed(0)} MB).`,
         );
+        return;
+      }
 
-        if (!result.ok) {
-          p.log.warn(`     Failed to upload: ${result.error}`);
-        }
-      } catch (error) {
-        p.log.warn(`     Error processing ${relativePath}: ${error.message}`);
+      const content = await readFile(absolutePath);
+      const result = await uploadFileWithRetries(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+        content,
+        async (_, nextAttempt) => {
+          p.log.warn(
+            `     Retry upload ${relativePath} (${nextAttempt}/${RETRY_ATTEMPTS})`,
+          );
+        },
+      );
+
+      if (!result.ok) {
+        p.log.warn(`     Failed to upload after ${RETRY_ATTEMPTS} attempts: ${result.error}`);
+      } else {
+        localPreviewServer?.notifyReload();
       }
-    }, DEBOUNCE_MS);
+    } catch (error) {
+      p.log.warn(`     Error processing ${relativePath}: ${error.message}`);
+    } finally {
+      inFlightPaths.delete(relativePath);
 
-    debounceMap.set(relativePath, timer);
+      if (pendingResyncPaths.delete(relativePath)) {
+        queueSync(relativePath);
+      }
+    }
+  };
+
+  const watcher = watch(rootDir, { recursive: true }, (eventType, filename) => {
+    if (!filename) return;
+    if (hasDotfileSegment(filename)) return;
+    if (shouldIgnoreWatchedPath(filename, builtTheme)) return;
+
+    const relativePath = filename.split(path.sep).join("/");
+    queueSync(relativePath);
   });
 
+  let cleanedUp = false;
   const cleanup = async () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+
     watcher.close();
     for (const timer of debounceMap.values()) clearTimeout(timer);
+    if (localPreviewServer) await localPreviewServer.close();
     if (buildCleanup) await buildCleanup();
     p.outro("Dev mode stopped.");
     process.exit(0);

package/lib/fs-utils.mjs

@@ -0,0 +1,35 @@
+import { access, readdir } from "node:fs/promises";
+import path from "node:path";
+
+export const isDotfile = (name) => name.startsWith(".");
+
+export const fileExists = async (filePath) => {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const listFilesRecursive = async (absoluteDir) => {
+  const entries = await readdir(absoluteDir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    if (isDotfile(entry.name)) continue;
+
+    const absolutePath = path.join(absoluteDir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...(await listFilesRecursive(absolutePath)));
+      continue;
+    }
+
+    if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+
+  return files.sort((left, right) => left.localeCompare(right));
+};