@swoff/cli 0.3.5 → 0.3.6

package/dist/lib/generators/file-generators/auth-fetch.js

@@ -1,34 +1,33 @@
 /**
- * Generates auth-fetch.ts/js — config-driven authenticated fetch wrapper.
- * Uses auth config to generate appropriate withAuthHeaders() and isAuthUrl().
+ * Generates auth-fetch.ts/js — thin auth wrapper around fetchWithCache.
  */
 import { writeFile } from "./context.js";
 export function generateAuthFetch(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const T = (type) => (ts ? `: ${type}` : "");
+    const R = (type) => (ts ? `: ${type} ` : " ");
     const authConfig = ctx.config.features.auth;
     const { refreshPath, userEndpoint, type } = authConfig;
     function generateWithAuthHeaders() {
+        const a = T("AuthData | null");
+        const h = T("Headers");
+        const hd = T("Headers");
         switch (type) {
             case "cookie":
-                return `function withAuthHeaders(headers, _auth) {
-  // Cookie/Session auth — browser auto-sends cookies.
-  // No header modification needed.
+                return `function withAuthHeaders(headers${hd}, _auth${a})${h}{
   return headers;
 }`;
             case "bearer":
-                return `function withAuthHeaders(headers, auth) {
-  // --- EDIT THIS BLOCK FOR YOUR BACKEND ---
-  // JWT Bearer token:
+                return `function withAuthHeaders(headers${hd}, auth${a})${h}{
   if (auth?.token) {
     headers.set("Authorization", \`Bearer \${auth.token}\`);
   }
-  // --- END OF EDITABLE BLOCK ---
   return headers;
 }`;
             case "custom":
-                return `function withAuthHeaders(headers, auth) {
+                return `function withAuthHeaders(headers${hd}, auth${a})${h}{
   // --- EDIT THIS BLOCK FOR YOUR BACKEND ---
-  // Custom header (e.g., X-API-Key, X-Auth-Token):
   // if (auth?.token) {
   //   headers.set("X-Auth-Token", auth.token);
   // }
@@ -36,30 +35,32 @@ export function generateAuthFetch(ctx) {
   return headers;
 }`;
             default:
-                return `function withAuthHeaders(headers, auth) {
-  // --- EDIT THIS BLOCK FOR YOUR BACKEND ---
+                return `function withAuthHeaders(headers${hd}, auth${a})${h}{
   if (auth?.token) {
     headers.set("Authorization", \`Bearer \${auth.token}\`);
   }
-  // --- END OF EDITABLE BLOCK ---
   return headers;
 }`;
         }
     }
     const credentialsLine = type === "cookie"
-        ? `const fetchOptions = { ...options, headers, credentials: "include" };`
-        : `const fetchOptions = { ...options, headers };`;
+        ? `  const fetchOptions = { ...options, headers, credentials: "include" };`
+        : `  const fetchOptions = { ...options, headers };`;
     const code = `/**
- * Auth-Aware Fetch — attaches auth headers, excludes auth endpoints from cache,
- * and handles 401 responses.
+ * Auth-Fetch — attaches auth headers, excludes auth endpoints from cache,
+ * and handles 401 responses. Thin wrapper around fetchWithCache.
  *
  * Usage:
- *   import { authenticatedFetch } from "./auth-fetch.${ext}";
+ *   import { authenticatedFetch } from "./auth/fetch.${ext}";
  *   const data = await authenticatedFetch("/api/data").then((r) => r.json());
+ *
+ * Or use fetchWithCache directly:
+ *   import { fetchWithCache } from "../fetch-wrapper.${ext}";
+ *   const data = await fetchWithCache("/api/me", { auth: true });
  */
 
-import { fetchWithCache } from "./fetch-wrapper.${ext}";
-import { getAuth, setAuth, clearAuth } from "./auth-store.${ext}";
+import { fetchWithCache } from "../fetch-wrapper.${ext}";
+import { getAuth, setAuth, clearAuth${ts ? ", type AuthData" : ""} } from "./store.${ext}";
 
 ${generateWithAuthHeaders()}
 
@@ -67,7 +68,7 @@ ${generateWithAuthHeaders()}
  * Auth endpoints that should never be cached by the SW.
  * Edit this list to match your backend's auth routes.
  */
-function isAuthUrl(url) {
+function isAuthUrl(url${T("string")})${R("boolean")}{
   const authPaths = [
     "/login",
     "/logout",
@@ -81,18 +82,13 @@ function isAuthUrl(url) {
   return authPaths.some((path) => url.includes(path));
 }
 
-/**
- * Auth-aware fetch wrapper.
- * Attaches identity, excludes auth endpoints from cache, handles 401.
- */
-export async function authenticatedFetch(input, options = {}) {
+/** Auth-aware fetch. Delegates to fetchWithCache with auth headers, cache bypass for auth endpoints, and 401 handling. */
+export async function authenticatedFetch(input${T("RequestInfo")}, options${T("RequestInit")} = {})${R("Promise<Response>")}{
   const auth = await getAuth();
   const headers = new Headers(options.headers);
 
-  // Attach auth headers (your backend determines how)
   withAuthHeaders(headers, auth);
 
-  // Determine if this is an auth endpoint (login, logout, refresh)
   const url = typeof input === "string" ? input : input.url;
 
   // Mark auth endpoints as mutation to bypass SW cache
@@ -101,7 +97,7 @@ export async function authenticatedFetch(input, options = {}) {
   }
 
   ${credentialsLine}
-  const response = await fetchWithCache(input, fetchOptions);
+  const { response } = await fetchWithCache(input, fetchOptions);
 
   // Handle 401 — auth expired or invalidated server-side
   if (response.status === 401) {
@@ -116,14 +112,13 @@ export async function authenticatedFetch(input, options = {}) {
  * Token refresh helper — called before requests when token may be expired.
  * Uses refreshPath from config.
  */
-let refreshPromise = null;
+let refreshPromise${T("Promise<AuthData | null> | null")} = null;
 
-export async function ensureValidAuth() {
+export async function ensureValidAuth()${R("Promise<AuthData | null>")}{
   const auth = await getAuth();
   if (!auth) return null;
   if (!auth.expiresAt || Date.now() < auth.expiresAt) return auth;
 
-  // Token expired — refresh it (deduplicated)
   if (!refreshPromise) {
     refreshPromise = (async () => {
       const response = await authenticatedFetch("${refreshPath}", {
@@ -151,6 +146,6 @@ export async function ensureValidAuth() {
   }
 }
 `;
-    writeFile(ctx, `auth-fetch.${ext}`, code);
+    writeFile(ctx, `auth/fetch.${ext}`, code);
 }
 //# sourceMappingURL=auth-fetch.js.map

package/dist/lib/generators/file-generators/auth-fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-fetch.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-fetch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5C,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;IAEvD,SAAS,uBAAuB;QAC9B,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,QAAQ;gBACX,OAAO;;;;EAIb,CAAC;YACG,KAAK,QAAQ;gBACX,OAAO;;;;;;;;EAQb,CAAC;YACG,KAAK,QAAQ;gBACX,OAAO;;;;;;;;EAQb,CAAC;YACG;gBACE,OAAO;;;;;;;EAOb,CAAC;QACC,CAAC;IACH,CAAC;IAED,MAAM,eAAe,GACnB,IAAI,KAAK,QAAQ;QACf,CAAC,CAAC,uEAAuE;QACzE,CAAC,CAAC,+CAA+C,CAAC;IAEtD,MAAM,IAAI,GAAG;;;;;wDAKyC,GAAG;;;;kDAIT,GAAG;4DACO,GAAG;;EAE7D,uBAAuB,EAAE;;;;;;;;;;;;;;OAcpB,WAAW;OACX,YAAY;;;;;;;;;;;;;;;;;;;;;;;;IAwBf,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;mDA0BgC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;CAwB7D,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}
+{"version":3,"file":"auth-fetch.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-fetch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEtD,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5C,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;IAEvD,SAAS,uBAAuB;QAC9B,MAAM,CAAC,GAAG,CAAC,CAAC,iBAAiB,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QACvB,MAAM,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QACxB,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,QAAQ;gBACX,OAAO,mCAAmC,EAAE,UAAU,CAAC,IAAI,CAAC;;EAElE,CAAC;YACG,KAAK,QAAQ;gBACX,OAAO,mCAAmC,EAAE,SAAS,CAAC,IAAI,CAAC;;;;;EAKjE,CAAC;YACG,KAAK,QAAQ;gBACX,OAAO,mCAAmC,EAAE,SAAS,CAAC,IAAI,CAAC;;;;;;;EAOjE,CAAC;YACG;gBACE,OAAO,mCAAmC,EAAE,SAAS,CAAC,IAAI,CAAC;;;;;EAKjE,CAAC;QACC,CAAC;IACH,CAAC;IAED,MAAM,eAAe,GACnB,IAAI,KAAK,QAAQ;QACf,CAAC,CAAC,yEAAyE;QAC3E,CAAC,CAAC,iDAAiD,CAAC;IAExD,MAAM,IAAI,GAAG;;;;;wDAKyC,GAAG;;;;wDAIH,GAAG;;;;mDAIR,GAAG;sCAChB,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,oBAAoB,GAAG;;EAEtF,uBAAuB,EAAE;;;;;;wBAMH,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;;;;;;;;OAQ5C,WAAW;OACX,YAAY;;;;;;gDAM6B,CAAC,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,mBAAmB,CAAC;;;;;;;;;;;;;IAavH,eAAe;;;;;;;;;;;;;;;;oBAgBC,CAAC,CAAC,iCAAiC,CAAC;;yCAEf,CAAC,CAAC,0BAA0B,CAAC;;;;;;;mDAOnB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;CAwB7D,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}

package/dist/lib/generators/file-generators/auth-state.js

@@ -4,6 +4,8 @@
 import { writeFile } from "./context.js";
 export function generateAuthState(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const R = (type) => (ts ? `: ${type} ` : " ");
     const code = `/**
  * Auth State — detect the four auth states for offline/online handling.
  *
@@ -14,14 +16,15 @@ export function generateAuthState(ctx) {
  *   4. Offline + Unauthenticated → Strict offline (public content only)
  *
  * Usage:
- *   import { getAuthState } from "./auth-state.${ext}";
+ *   import { getAuthState } from "./auth/state.${ext}";
  *   const { authenticated, user, online } = await getAuthState();
  */
 
-import { getAuth, isAuthValid } from "./auth-store.${ext}";
-import { getCachedUser } from "./auth-user.${ext}";
+import { getAuth, isAuthValid } from "./store.${ext}";
+import { getCachedUser } from "./user.${ext}";
 
-export async function getAuthState() {
+/** Detect current auth state across the 4-state matrix (online/offline × authenticated/not). */
+export async function getAuthState()${R("Promise<{ authenticated: boolean; user: Record<string, unknown> | null; online: boolean }>")}{
   const auth = await getAuth();
   const valid = isAuthValid(auth);
   const user = valid ? await getCachedUser() : null;
@@ -33,6 +36,6 @@ export async function getAuthState() {
   };
 }
 `;
-    writeFile(ctx, `auth-state.${ext}`, code);
+    writeFile(ctx, `auth/state.${ext}`, code);
 }
 //# sourceMappingURL=auth-state.js.map

package/dist/lib/generators/file-generators/auth-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-state.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-state.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;;;;;;kDAUmC,GAAG;;;;qDAIA,GAAG;6CACX,GAAG;;;;;;;;;;;;;CAa/C,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}
+{"version":3,"file":"auth-state.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-state.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEtD,MAAM,IAAI,GAAG;;;;;;;;;;kDAUmC,GAAG;;;;gDAIL,GAAG;wCACX,GAAG;;;sCAGL,CAAC,CAAC,4FAA4F,CAAC;;;;;;;;;;;CAWpI,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}

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

@@ -9,6 +9,49 @@
 import { writeFile } from "./context.js";
 export function generateAuthStore(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const T = (type) => (ts ? `: ${type}` : "");
+    const R = (type) => (ts ? `: ${type} ` : " ");
+    const PT = (type) => (ts ? `<${type}>` : "");
+    const AS = (type) => (ts ? ` as ${type}` : "");
+    const authDataInterface = ts ? `export interface AuthData {
+  token?: string;
+  user?: Record<string, unknown>;
+  expiresAt?: number;
+}
+
+export interface AuthResponse extends Record<string, unknown> {
+  // Uncomment and type the fields your backend's login response returns:
+  // token: string;
+  // user: Record<string, unknown>;
+  // expiresAt?: number;
+}
+
+` : "";
+    const createAuthFromResponseBlock = ts
+        ? `/** Extract AuthData from your backend's login response. Edit this function to match your backend's response shape. */
+export function createAuthFromResponse(response: AuthResponse): AuthData {
+  // --- EDIT THIS TO MATCH YOUR BACKEND ---
+  const data = response as Record<string, unknown>;
+  return {
+    token: data.token as string,
+    user: data.user as Record<string, unknown> | undefined,
+    expiresAt: data.expiresAt as number | undefined,
+  };
+  // --- END OF EDITABLE BLOCK ---
+}
+`
+        : `/** Extract AuthData from your backend's login response. Edit this function to match your backend's response shape. */
+export function createAuthFromResponse(response) {
+  // --- EDIT THIS TO MATCH YOUR BACKEND ---
+  return {
+    token: response.token,
+    user: response.user,
+    expiresAt: response.expiresAt,
+  };
+  // --- END OF EDITABLE BLOCK ---
+}
+`;
     const code = `/**
  * Auth Store — Token in memory only; user info in IndexedDB for offline access.
  *
@@ -18,110 +61,98 @@ export function generateAuthStore(ctx) {
  *   user info offline. After a page refresh, re-login is required.
  *
  * Usage:
- *   import { setAuth, getAuth, clearAuth, isAuthValid } from "./auth-store.${ext}";
+ *   import { setAuth, getAuth, clearAuth, isAuthValid } from "./auth/store.${ext}";
  *
  *   await setAuth({ token, user, expiresAt });
  *   const auth = await getAuth();
  *   await clearAuth();
  */
 
-const DB_NAME = "swoff-auth";
+${authDataInterface}const DB_NAME = "swoff-auth";
 const STORE_NAME = "auth";
 
-let memoryAuth = null;
+let memoryAuth${T("AuthData | null")} = null;
 
-function openAuthDB() {
-  return new Promise((resolve, reject) => {
+${createAuthFromResponseBlock}
+function openAuthDB()${R("Promise<IDBDatabase>")}{
+  return new Promise${PT("IDBDatabase")}((resolve, reject) => {
     const request = indexedDB.open(DB_NAME, 1);
     request.onupgradeneeded = (e) => {
-      const db = e.target.result;
+      const db = (e.target${AS("IDBOpenDBRequest")}).result;
       if (!db.objectStoreNames.contains(STORE_NAME)) {
         db.createObjectStore(STORE_NAME, { keyPath: "key" });
       }
     };
-    request.onsuccess = (e) => resolve(e.target.result);
-    request.onerror = (e) => reject(e.target.error);
+    request.onsuccess = (e) => resolve((e.target${AS("IDBOpenDBRequest")}).result);
+    request.onerror = (e) => reject((e.target${AS("IDBRequest")}).error);
   });
 }
 
-async function persistUserData(authData) {
+async function persistUserData(authData${T("AuthData | null")})${R("Promise<void>")}{
   // Only persist { user, expiresAt } — never the token
   const userData = { user: authData?.user, expiresAt: authData?.expiresAt };
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise${PT("void")}((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readwrite");
     const store = tx.objectStore(STORE_NAME);
     const request = store.put({ key: "session", value: userData });
     request.onsuccess = () => resolve();
-    request.onerror = () => reject(request.error);
+    request.onerror = () => reject((request${AS("IDBRequest")}).error);
   });
 }
 
-async function loadUserData() {
+async function loadUserData()${R("Promise<{ user?: Record<string, unknown>; expiresAt?: number } | null>")}{
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise${PT("any")}((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readonly");
     const store = tx.objectStore(STORE_NAME);
     const request = store.get("session");
-    request.onsuccess = () => resolve(request.result?.value || null);
-    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve((request${AS("IDBRequest")}).result?.value ?? null);
+    request.onerror = () => reject((request${AS("IDBRequest")}).error);
   });
 }
 
-async function clearPersistedData() {
+async function clearPersistedData()${R("Promise<void>")}{
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise${PT("void")}((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readwrite");
     const store = tx.objectStore(STORE_NAME);
     const request = store.delete("session");
     request.onsuccess = () => resolve();
-    request.onerror = () => reject(request.error);
+    request.onerror = () => reject((request${AS("IDBRequest")}).error);
   });
 }
 
-/**
- * Store auth data — token stays in memory only.
- * Only user info and expiry are persisted to IndexedDB.
- * @param {{ token?: string, user?: object, expiresAt?: number }} authData
- */
-export async function setAuth(authData) {
+/** Store auth data in memory and persist user info to IndexedDB for offline access. */
+export async function setAuth(authData${T("AuthData")})${R("Promise<void>")}{
   memoryAuth = authData;
   await persistUserData(authData);
 }
 
-/**
- * Get stored auth — returns memory copy (with token) or
- * falls back to IndexedDB (user info only, no token after refresh).
- */
-export async function getAuth() {
+/** Get auth data from memory (or IndexedDB if memory is empty after page refresh). */
+export async function getAuth()${R("Promise<AuthData | null>")}{
   if (memoryAuth) return memoryAuth;
 
   const userData = await loadUserData();
   if (userData) {
-    // After refresh: user info available, but no token — re-login required
     memoryAuth = userData;
   }
   return memoryAuth;
 }
 
-/**
- * Clear auth — removes from memory and IndexedDB.
- */
-export async function clearAuth() {
+/** Clear auth from memory and IndexedDB. Call on logout or 401. */
+export async function clearAuth()${R("Promise<void>")}{
   memoryAuth = null;
   await clearPersistedData();
 }
 
-/**
- * Check if auth exists and is not expired.
- * @param {object | null} auth — The auth object from getAuth()
- */
-export function isAuthValid(auth) {
+/** Check if auth exists and has not expired. Returns true if no expiresAt is set. */
+export function isAuthValid(auth${T("AuthData | null")})${R("boolean")}{
   if (!auth) return false;
   if (!auth.expiresAt) return true;
   return Date.now() < auth.expiresAt;
 }
 `;
-    writeFile(ctx, `auth-store.${ext}`, code);
+    writeFile(ctx, `auth/store.${ext}`, code);
 }
 //# sourceMappingURL=auth-store.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"auth-store.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;;;;;8EAS+D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuGhF,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}
+{"version":3,"file":"auth-store.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IAExB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtD,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACrD,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAEvD,MAAM,iBAAiB,GAAG,EAAE,CAAC,CAAC,CAAC;;;;;;;;;;;;;CAahC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEL,MAAM,2BAA2B,GAAG,EAAE;QACpC,CAAC,CAAC;;;;;;;;;;;CAWL;QACG,CAAC,CAAC;;;;;;;;;;CAUL,CAAC;IAEA,MAAM,IAAI,GAAG;;;;;;;;;8EAS+D,GAAG;;;;;;;EAO/E,iBAAiB;;;gBAGH,CAAC,CAAC,iBAAiB,CAAC;;EAElC,2BAA2B;uBACN,CAAC,CAAC,sBAAsB,CAAC;sBAC1B,EAAE,CAAC,aAAa,CAAC;;;4BAGX,EAAE,CAAC,kBAAkB,CAAC;;;;;kDAKA,EAAE,CAAC,kBAAkB,CAAC;+CACzB,EAAE,CAAC,YAAY,CAAC;;;;yCAItB,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;sBAI7D,EAAE,CAAC,MAAM,CAAC;;;;;6CAKa,EAAE,CAAC,YAAY,CAAC;;;;+BAI9B,CAAC,CAAC,wEAAwE,CAAC;;sBAEpF,EAAE,CAAC,KAAK,CAAC;;;;gDAIiB,EAAE,CAAC,YAAY,CAAC;6CACnB,EAAE,CAAC,YAAY,CAAC;;;;qCAIxB,CAAC,CAAC,eAAe,CAAC;;sBAEjC,EAAE,CAAC,MAAM,CAAC;;;;;6CAKa,EAAE,CAAC,YAAY,CAAC;;;;;wCAKrB,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;;;iCAM1C,CAAC,CAAC,0BAA0B,CAAC;;;;;;;;;;;mCAW3B,CAAC,CAAC,eAAe,CAAC;;;;;;kCAMnB,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;;;;;CAKrE,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}

package/dist/lib/generators/file-generators/auth-user.js

@@ -4,42 +4,44 @@
 import { writeFile } from "./context.js";
 export function generateAuthUser(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const T = (type) => (ts ? `: ${type}` : "");
+    const R = (type) => (ts ? `: ${type} ` : " ");
+    const PT = (type) => (ts ? `<${type}>` : "");
+    const AS = (type) => (ts ? ` as ${type}` : "");
     const userEndpoint = ctx.config.features.auth.userEndpoint;
     const code = `/**
  * Current User — fetch, cache, and invalidate the current user for offline access.
  *
  * Usage:
- *   import { fetchCurrentUser, cacheUser, getCachedUser, clearCachedUser } from "./auth-user.${ext}";
+ *   import { fetchCurrentUser, cacheUser, getCachedUser, clearCachedUser } from "./auth/user.${ext}";
  *
  *   await fetchCurrentUser();           // Fetch from server & cache
  *   const user = await getCachedUser(); // Get cached (offline-capable)
  *   await clearCachedUser();            // Clear on logout
  */
 
-import { authenticatedFetch } from "./auth-fetch.${ext}";
+import { authenticatedFetch } from "./fetch.${ext}";
 
 const DB_NAME = "swoff-auth-user";
 const STORE_NAME = "current-user";
 
-function openAuthDB() {
-  return new Promise((resolve, reject) => {
+function openAuthDB()${R("Promise<IDBDatabase>")}{
+  return new Promise${PT("IDBDatabase")}((resolve, reject) => {
     const request = indexedDB.open(DB_NAME, 1);
     request.onupgradeneeded = (e) => {
-      const db = e.target.result;
+      const db = (e.target${AS("IDBOpenDBRequest")}).result;
       if (!db.objectStoreNames.contains(STORE_NAME)) {
         db.createObjectStore(STORE_NAME, { keyPath: "key" });
       }
     };
-    request.onsuccess = (e) => resolve(e.target.result);
-    request.onerror = (e) => reject(e.target.error);
+    request.onsuccess = (e) => resolve((e.target${AS("IDBOpenDBRequest")}).result);
+    request.onerror = (e) => reject((e.target${AS("IDBRequest")}).error);
   });
 }
 
-/**
- * Fetch current user from your backend and cache locally.
- * Uses userEndpoint from swoff.config.json.
- */
-export async function fetchCurrentUser() {
+/** Fetch current user from the user endpoint and cache the result in IndexedDB. */
+export async function fetchCurrentUser()${R("Promise<Record<string, unknown>>")}{
   const response = await authenticatedFetch("${userEndpoint}");
   if (!response.ok) throw new Error("Failed to fetch user");
 
@@ -48,12 +50,10 @@ export async function fetchCurrentUser() {
   return user;
 }
 
-/**
- * Store user in IndexedDB for offline access.
- */
-export async function cacheUser(user) {
+/** Persist user data to IndexedDB for offline access. */
+export async function cacheUser(user${T("Record<string, unknown>")})${R("Promise<void>")}{
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise<void>((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readwrite");
     const store = tx.objectStore(STORE_NAME);
     store.put({ key: "user", value: user });
@@ -62,34 +62,30 @@ export async function cacheUser(user) {
   });
 }
 
-/**
- * Get cached user — works offline.
- */
-export async function getCachedUser() {
+/** Load user data from IndexedDB cache (no token — only user object survives refresh). */
+export async function getCachedUser()${R("Promise<Record<string, unknown> | null>")}{
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise${PT("Record<string, unknown> | null")}((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readonly");
     const store = tx.objectStore(STORE_NAME);
     const request = store.get("user");
-    request.onsuccess = () => resolve(request.result?.value || null);
-    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve((request${AS("IDBRequest")}).result?.value ?? null);
+    request.onerror = () => reject((request${AS("IDBRequest")}).error);
   });
 }
 
-/**
- * Clear cached user on logout.
- */
-export async function clearCachedUser() {
+/** Remove user data from IndexedDB cache. Call on logout. */
+export async function clearCachedUser()${R("Promise<void>")}{
   const db = await openAuthDB();
-  return new Promise((resolve, reject) => {
+  return new Promise${PT("void")}((resolve, reject) => {
     const tx = db.transaction(STORE_NAME, "readwrite");
     const store = tx.objectStore(STORE_NAME);
     store.delete("user");
     tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
+    tx.onerror = () => reject((tx${AS("IDBTransaction")}).error);
   });
 }
 `;
-    writeFile(ctx, `auth-user.${ext}`, code);
+    writeFile(ctx, `auth/user.${ext}`, code);
 }
 //# sourceMappingURL=auth-user.js.map

package/dist/lib/generators/file-generators/auth-user.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-user.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-user.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,gBAAgB,CAAC,GAAqB;IACpD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;IAE3D,MAAM,IAAI,GAAG;;;;gGAIiF,GAAG;;;;;;;mDAOhD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;+CAwBP,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD1D,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"auth-user.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/auth-user.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,gBAAgB,CAAC,GAAqB;IACpD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtD,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACrD,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACvD,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;IAE3D,MAAM,IAAI,GAAG;;;;gGAIiF,GAAG;;;;;;;8CAOrD,GAAG;;;;;uBAK1B,CAAC,CAAC,sBAAsB,CAAC;sBAC1B,EAAE,CAAC,aAAa,CAAC;;;4BAGX,EAAE,CAAC,kBAAkB,CAAC;;;;;kDAKA,EAAE,CAAC,kBAAkB,CAAC;+CACzB,EAAE,CAAC,YAAY,CAAC;;;;;0CAKrB,CAAC,CAAC,kCAAkC,CAAC;+CAChC,YAAY;;;;;;;;;sCASrB,CAAC,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;;;;;;;;;uCAYjD,CAAC,CAAC,yCAAyC,CAAC;;sBAE7D,EAAE,CAAC,gCAAgC,CAAC;;;;gDAIV,EAAE,CAAC,YAAY,CAAC;6CACnB,EAAE,CAAC,YAAY,CAAC;;;;;yCAKpB,CAAC,CAAC,eAAe,CAAC;;sBAErC,EAAE,CAAC,MAAM,CAAC;;;;;mCAKG,EAAE,CAAC,gBAAgB,CAAC;;;CAGtD,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC"}

package/dist/lib/generators/file-generators/background-sync.js

@@ -4,6 +4,9 @@
 import { writeFile } from "./context.js";
 export function generateBackgroundSync(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const T = (type) => (ts ? `: ${type}` : "");
+    const R = (type) => (ts ? `: ${type} ` : " ");
     const code = `/**
  * Swoff Background Sync
  * Register sync events for processing mutation queue after tab close.
@@ -17,8 +20,7 @@ export function generateBackgroundSync(ctx) {
  *     url: "/api/todos",
  *     body: { title: "Grocery" },
  *     tags: ["todos"],
- *     storeName: "todos",
- *     tempId: "temp_abc123",
+ *     tags: ["todos"],
  *   });
  */
 
@@ -26,7 +28,7 @@ import { queueMutation, processMutationQueue, getPendingCount } from "./mutation
 
 const SYNC_TAG = "sync-mutations";
 
-async function registerSync() {
+async function registerSync()${R("Promise<void>")}{
   if (!("serviceWorker" in navigator) || !("SyncManager" in window)) {
     window.addEventListener("online", processMutationQueue, { once: true });
     return;
@@ -40,12 +42,14 @@ async function registerSync() {
   }
 }
 
-export async function syncWhenPossible(mutation) {
+/** Queue a mutation and register a background sync event so it runs even after tab close. */
+export async function syncWhenPossible(mutation${T("object")})${R("Promise<void>")}{
   await queueMutation(mutation);
   await registerSync();
 }
 
-export async function retrySync() {
+/** Re-register a background sync if mutations are still pending. Called automatically after each sync cycle. */
+export async function retrySync()${R("Promise<void>")}{
   if (!("serviceWorker" in navigator) || !("SyncManager" in window)) return;
   const count = await getPendingCount();
   if (count > 0) {

package/dist/lib/generators/file-generators/background-sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"background-sync.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/background-sync.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,sBAAsB,CAAC,GAAqB;IAC1D,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,IAAI,GAAG;;;;;;iEAMkD,GAAG;;;;;;;;;;;;yFAYqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC3F,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,mBAAmB,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC"}
+{"version":3,"file":"background-sync.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/background-sync.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,sBAAsB,CAAC,GAAqB;IAC1D,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEtD,MAAM,IAAI,GAAG;;;;;;iEAMkD,GAAG;;;;;;;;;;;yFAWqB,GAAG;;;;+BAI7D,CAAC,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;iDAeA,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;;;mCAM/C,CAAC,CAAC,eAAe,CAAC;;;;;;;;;CASpD,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,mBAAmB,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC"}

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

@@ -4,6 +4,9 @@
 import { writeFile } from "./context.js";
 export function generateCache(ctx) {
     const ext = ctx.ext;
+    const ts = ext === "ts";
+    const T = (type) => (ts ? `: ${type}` : "");
+    const R = (type) => (ts ? `: ${type} ` : " ");
     const code = `/**
  * Swoff Cache Invalidation
  * Framework-agnostic cache tag invalidation.
@@ -15,7 +18,8 @@ export function generateCache(ctx) {
  *   await invalidateByTag("todos");
  */
 
-export async function invalidateByTag(tag) {
+/** Invalidate all cached responses tagged with the given tag. Dispatches cache-invalidated event. */
+export async function invalidateByTag(tag${T("string")})${R("Promise<void>")}{
   if (!navigator.serviceWorker?.controller) return;
 
   navigator.serviceWorker.controller.postMessage({
@@ -28,7 +32,8 @@ export async function invalidateByTag(tag) {
   );
 }
 
-export async function invalidateByTags(tags) {
+/** Invalidate all cached responses matching any of the given tags. */
+export async function invalidateByTags(tags${T("string[]")})${R("Promise<void>")}{
   for (const tag of tags) {
     await invalidateByTag(tag);
   }

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

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/cache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,aAAa,CAAC,GAAqB;IACjD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;sDAKuC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBxD,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/cache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,aAAa,CAAC,GAAqB;IACjD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,EAAE,GAAG,GAAG,KAAK,IAAI,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEtD,MAAM,IAAI,GAAG;;;;;sDAKuC,GAAG;;;;;;;2CAOd,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;;;;;;;;;;;6CAc/B,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,eAAe,CAAC;;;;;CAK/E,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}