@swoff/cli 0.0.2 → 0.2.0

package/dist/lib/generators/file-generators/mutation-queue.js

@@ -0,0 +1,226 @@
+/**
+ * Generates mutation-queue.js - offline mutation queue with IndexedDB.
+ */
+import { writeFile } from "./context.js";
+export function generateMutationQueue(ctx) {
+    const code = `/**
+ * Swoff Mutation Queue
+ * Queue offline writes and sync when connection returns.
+ *
+ * Usage:
+ *   import { queueMutation, processMutationQueue, getPendingCount } from './swoff/mutation-queue.js';
+ *
+ *   // Queue a mutation
+ *   await queueMutation({
+ *     method: "POST",
+ *     url: "/api/todos",
+ *     body: { title: "Grocery" },
+ *     tags: ["todos"],
+ *     storeName: "todos",
+ *     tempId: "temp_abc123",
+ *   });
+ *
+ *   // Auto-processes on online event
+ */
+
+const DB_NAME = "swoff-queue";
+const STORE_NAME = "mutations";
+const MAX_RETRIES = 5;
+
+function openQueueDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, 1);
+    request.onupgradeneeded = (e) => {
+      const db = e.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        store.createIndex("by-timestamp", "timestamp");
+      }
+    };
+    request.onsuccess = (e) => resolve(e.target.result);
+    request.onerror = (e) => reject(e.target.error);
+  });
+}
+
+let isSyncing = false;
+
+export async function queueMutation(mutation) {
+  const db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  const store = tx.objectStore(STORE_NAME);
+
+  store.add({
+    id: crypto.randomUUID(),
+    method: mutation.method,
+    url: mutation.url,
+    body: mutation.body,
+    headers: mutation.headers || {},
+    previousData: mutation.previousData || null,
+    timestamp: Date.now(),
+    retryCount: 0,
+    tags: mutation.tags || [],
+    storeName: mutation.storeName || null,
+    tempId: mutation.tempId || null,
+  });
+
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+
+  window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+}
+
+export async function processMutationQueue() {
+  if (!navigator.onLine || isSyncing) return;
+  isSyncing = true;
+
+  try {
+    const db = await openQueueDB();
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const index = store.index("by-timestamp");
+    const queue = await new Promise((resolve, reject) => {
+      const request = index.getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+
+    let succeeded = 0;
+    let failed = 0;
+
+    for (const item of queue) {
+      if (item.retryCount >= MAX_RETRIES) {
+        await rollbackMutation(item);
+        await removeFromQueue(item.id);
+        failed++;
+        continue;
+      }
+
+      try {
+        const response = await fetch(item.url, {
+          method: item.method,
+          headers: {
+            "Content-Type": "application/json",
+            ...item.headers,
+          },
+          body: JSON.stringify(item.body),
+        });
+
+        if (!response.ok) throw new Error(\`HTTP \${response.status}\`);
+
+        const serverData = await response.json();
+
+        if (item.tempId && item.storeName) {
+          await reconcileRecord(item.storeName, item.tempId, serverData);
+        }
+
+        if (item.tags && item.tags.length > 0) {
+          const { invalidateByTags } = await import("./cache.js");
+          await invalidateByTags(item.tags);
+        }
+
+        await removeFromQueue(item.id);
+        succeeded++;
+      } catch {
+        item.retryCount++;
+        await updateInQueue(item);
+        failed++;
+      }
+    }
+
+    window.dispatchEvent(
+      new CustomEvent("mutation-sync-complete", {
+        detail: { succeeded, failed },
+      })
+    );
+  } finally {
+    isSyncing = false;
+    window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+  }
+}
+
+async function removeFromQueue(id) {
+  const db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  tx.objectStore(STORE_NAME).delete(id);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+async function updateInQueue(item) {
+  const db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  tx.objectStore(STORE_NAME).put(item);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+async function rollbackMutation(item) {
+  if (!item.storeName) return;
+
+  if (item.method === "POST" && item.tempId) {
+    const { deleteRecord } = await import("./store.js");
+    await deleteRecord(item.storeName, item.tempId);
+  } else if (
+    (item.method === "PUT" || item.method === "PATCH") &&
+    item.previousData
+  ) {
+    const { putRecord } = await import("./store.js");
+    await putRecord(item.storeName, { ...item.previousData, $synced: true });
+  } else if (item.method === "DELETE" && item.tempId && item.previousData) {
+    const { putRecord } = await import("./store.js");
+    await putRecord(item.storeName, { ...item.previousData, $synced: true });
+  }
+
+  window.dispatchEvent(
+    new CustomEvent("mutation-rollback", {
+      detail: {
+        method: item.method,
+        url: item.url,
+        tempId: item.tempId,
+        previousData: item.previousData,
+      },
+    })
+  );
+}
+
+async function reconcileRecord(storeName, tempId, serverData) {
+  const { getRecord, putRecord, deleteRecord } = await import("./store.js");
+  const existing = await getRecord(storeName, tempId);
+  if (!existing) return;
+
+  const reconciled = {
+    ...existing,
+    ...serverData,
+    id: serverData.id,
+    $synced: true,
+    $syncedAt: Date.now(),
+  };
+
+  await putRecord(storeName, reconciled);
+
+  if (String(tempId) !== String(serverData.id)) {
+    await deleteRecord(storeName, tempId);
+  }
+}
+
+export async function getPendingCount() {
+  const db = await openQueueDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const request = tx.objectStore(STORE_NAME).count();
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+window.addEventListener("online", processMutationQueue);
+`;
+    writeFile(ctx, "mutation-queue.js", code);
+}
+//# sourceMappingURL=mutation-queue.js.map

package/dist/lib/generators/file-generators/mutation-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-queue.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/mutation-queue.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,qBAAqB,CAAC,GAAqB;IACzD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyNd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,mBAAmB,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}

package/dist/lib/generators/file-generators/pwa-install.js

@@ -0,0 +1,102 @@
+/**
+ * Generates pwa-install.js - PWA install prompt handler.
+ */
+import { writeFile } from "./context.js";
+export function generatePwaInstall(ctx) {
+    const preventDefault = ctx.config.pwa?.preventDefaultInstall ?? false;
+    const code = `/**
+ * Swoff PWA Install Prompt Handler
+ * Captures beforeinstallprompt event and provides manual install trigger.
+ *
+ * Usage:
+ *   import { isInstallable, promptInstall } from './swoff/pwa-install.js';
+ *
+ *   // Listen for installable event
+ *   window.addEventListener('pwa-installable', (e) => {
+ *     console.log('PWA can be installed:', e.detail.isInstallable);
+ *     // Show your custom install button
+ *   });
+ *
+ *   // When user clicks install button
+ *   async function onInstallClick() {
+ *     const result = await promptInstall();
+ *     console.log('User choice:', result);
+ *   }
+ *
+ * Window events:
+ *   pwa-installable  - PWA can be installed (detail: { isInstallable: true })
+ *   pwa-installed    - User accepted install (detail: { outcome: 'accepted' })
+ *   pwa-dismissed    - User dismissed install (detail: { outcome: 'dismissed' })
+ *
+ * Window properties:
+ *   window.deferredInstallPrompt - The captured BeforeInstallPromptEvent
+ *   window.pwaInstallable        - Whether PWA can be installed
+ */
+
+const PREVENT_DEFAULT_INSTALL = ${preventDefault};
+
+window.addEventListener("beforeinstallprompt", (e) => {
+  // Always capture the event so we never lose it
+  window.deferredInstallPrompt = e;
+  window.pwaInstallable = true;
+
+  if (PREVENT_DEFAULT_INSTALL) {
+    // Suppress browser's native prompt
+    e.preventDefault();
+  }
+  // When false, browser shows native prompt naturally
+  // but we still capture the event for manual triggering
+
+  window.dispatchEvent(
+    new CustomEvent("pwa-installable", {
+      detail: { isInstallable: true },
+    })
+  );
+});
+
+window.addEventListener("appinstalled", () => {
+  window.deferredInstallPrompt = null;
+  window.pwaInstallable = false;
+
+  window.dispatchEvent(
+    new CustomEvent("pwa-installed", {
+      detail: { outcome: "accepted" },
+    })
+  );
+});
+
+export function isInstallable() {
+  return !!window.deferredInstallPrompt;
+}
+
+export async function promptInstall() {
+  if (!window.deferredInstallPrompt) {
+    throw new Error("Install prompt not available");
+  }
+
+  const promptEvent = window.deferredInstallPrompt;
+  await promptEvent.prompt();
+
+  const choice = await promptEvent.userChoice;
+
+  if (choice.outcome === "accepted") {
+    window.dispatchEvent(
+      new CustomEvent("pwa-installed", {
+        detail: { outcome: "accepted" },
+      })
+    );
+  } else {
+    window.dispatchEvent(
+      new CustomEvent("pwa-dismissed", {
+        detail: { outcome: "dismissed" },
+      })
+    );
+  }
+
+  window.deferredInstallPrompt = null;
+  return choice;
+}
+`;
+    writeFile(ctx, "pwa-install.js", code);
+}
+//# sourceMappingURL=pwa-install.js.map

package/dist/lib/generators/file-generators/pwa-install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pwa-install.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/pwa-install.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,GAAqB;IACtD,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,qBAAqB,IAAI,KAAK,CAAC;IAEtE,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA6BmB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D/C,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC"}

package/dist/lib/generators/file-generators/reconcile.js

@@ -0,0 +1,54 @@
+/**
+ * Generates reconcile.js - ID reconciliation after mutation sync.
+ */
+import { writeFile } from "./context.js";
+export function generateReconcile(ctx) {
+    const code = `/**
+ * Swoff ID Reconciliation
+ * Update local records with server data after mutation sync.
+ *
+ * Usage:
+ *   import { reconcileRecord } from './swoff/reconcile.js';
+ *
+ *   await reconcileRecord('todos', 'temp_abc123', serverData);
+ */
+
+import { getRecord, putRecord, deleteRecord } from './store.js';
+
+export async function reconcileRecord(storeName, tempId, serverData) {
+  const existing = await getRecord(storeName, tempId);
+  if (!existing) return;
+
+  const reconciled = {
+    ...existing,
+    ...serverData,
+    id: serverData.id,
+    $synced: true,
+    $syncedAt: Date.now(),
+  };
+
+  await putRecord(storeName, reconciled);
+
+  if (String(tempId) !== String(serverData.id)) {
+    await deleteRecord(storeName, tempId);
+  }
+
+  await reconcileReferences(storeName, tempId, serverData.id);
+}
+
+export async function reconcileReferences(storeName, oldId, newId) {
+  // Override this for your app's schema.
+  // Example: update foreign-key references in related stores.
+  //
+  // const txns = await getAllRecords('transactions');
+  // for (const txn of txns) {
+  //   if (txn.todoId === oldId) {
+  //     txn.todoId = newId;
+  //     await putRecord('transactions', txn);
+  //   }
+  // }
+}
+`;
+    writeFile(ctx, "reconcile.js", code);
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/lib/generators/file-generators/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/reconcile.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Cd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}

package/dist/lib/generators/file-generators/store.js

@@ -0,0 +1,75 @@
+/**
+ * Generates store.js - IndexedDB CRUD operations.
+ */
+import { writeFile } from "./context.js";
+export function generateStore(ctx) {
+    const dbName = ctx.config.database?.name || "app-db";
+    const code = `/**
+ * Swoff IndexedDB Store
+ * Generic CRUD operations for app's IndexedDB database.
+ *
+ * Usage:
+ *   import { getRecord, putRecord, deleteRecord, openAppDB } from './swoff/store.js';
+ *
+ *   const record = await getRecord('todos', 'todo-123');
+ *   await putRecord('todos', { id: 'todo-123', title: 'New task', $synced: false });
+ *   await deleteRecord('todos', 'todo-123');
+ */
+
+const DB_NAME = "${dbName}";
+
+export function openAppDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME);
+    request.onsuccess = (e) => resolve(e.target.result);
+    request.onerror = (e) => reject(e.target.error);
+  });
+}
+
+export async function getRecord(storeName, id) {
+  const db = await openAppDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readonly");
+    const store = tx.objectStore(storeName);
+    const request = store.get(id);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function putRecord(storeName, record) {
+  const db = await openAppDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readwrite");
+    const store = tx.objectStore(storeName);
+    const request = store.put(record);
+    tx.oncomplete = () => resolve(request.result);
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+export async function deleteRecord(storeName, id) {
+  const db = await openAppDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readwrite");
+    const store = tx.objectStore(storeName);
+    const request = store.delete(id);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+export async function getAllRecords(storeName) {
+  const db = await openAppDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, "readonly");
+    const store = tx.objectStore(storeName);
+    const request = store.getAll();
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+`;
+    writeFile(ctx, "store.js", code);
+}
+//# sourceMappingURL=store.js.map

package/dist/lib/generators/file-generators/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,aAAa,CAAC,GAAqB;IACjD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,IAAI,QAAQ,CAAC;IAErD,MAAM,IAAI,GAAG;;;;;;;;;;;;mBAYI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDxB,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;AACnC,CAAC"}

package/dist/lib/generators/file-generators/sw-generator-build.js

@@ -0,0 +1,70 @@
+/**
+ * Generates sw-generator.js - build script that processes sw-template.js.
+ */
+import { writeFile } from "./context.js";
+export function generateSwGeneratorBuild(ctx) {
+    const code = `#!/usr/bin/env node
+/**
+ * Swoff SW Generator Build Script
+ * Reads swoff/sw-template.js and generates versioned SW output.
+ *
+ * Add to package.json:
+ *   "build": "your-build && node swoff/sw-generator.js"
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirname, '..');
+
+const pkgPath = join(projectRoot, 'package.json');
+const templatePath = join(__dirname, 'sw-template.js');
+const configPath = join(projectRoot, 'swoff.config.json');
+
+if (!existsSync(configPath)) {
+  console.error('Error: swoff.config.json not found');
+  console.log('Run "npx @swoff/cli init" to create one');
+  process.exit(1);
+}
+
+if (!existsSync(templatePath)) {
+  console.error('Error: swoff/sw-template.js not found');
+  process.exit(1);
+}
+
+const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, 'utf8')) : { version: '1.0.0' };
+const config = JSON.parse(readFileSync(configPath, 'utf8'));
+const template = readFileSync(templatePath, 'utf8');
+
+const version = config.version === 'from-package' ? pkg.version || '1.0.0' : config.version;
+const outputDir = config.build?.outputDir || 'dist';
+const swFilename = config.build?.swFilename || 'sw';
+
+let sw = template;
+sw = sw.replace('// [[CACHE_NAME]]', \`CACHE_NAME = 'sw-v\${version}'\`);
+
+const baseAssets = ['/', '/index.html'];
+const pwaAssets = config.features?.pwa ? ['/manifest.json'] : [];
+const assetsToCache = [...baseAssets, ...pwaAssets];
+sw = sw.replace('// [[ASSETS_LIST]]', \`ASSETS_TO_CACHE = \${JSON.stringify(assetsToCache.map(url => ({ url, options: {} })), null, 2)}\`);
+sw = sw.replace('// [[AUTO_SKIP_WAITING]]', \`const AUTO_SKIP_WAITING = \${config.serviceWorker?.autoUpdate || false};\`);
+
+const outDir = join(projectRoot, outputDir);
+if (!existsSync(outDir)) {
+  mkdirSync(outDir, { recursive: true });
+}
+
+writeFileSync(join(projectRoot, outputDir, \`\${swFilename}-v\${version}.js\`), sw);
+writeFileSync(join(projectRoot, outputDir, 'version.json'), JSON.stringify({
+  version,
+  minSupportedVersion: config.minSupportedVersion || '0.0.0',
+  generatedAt: new Date().toISOString(),
+}, null, 2));
+
+console.log(\`Service worker built: \${outputDir}/\${swFilename}-v\${version}.js\`);
+`;
+    writeFile(ctx, "sw-generator.js", code);
+}
+//# sourceMappingURL=sw-generator-build.js.map

package/dist/lib/generators/file-generators/sw-generator-build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sw-generator-build.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/sw-generator-build.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,wBAAwB,CAAC,GAAqB;IAC5D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Dd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC"}