@sweidos/eidos 1.0.34 → 1.2.0

package/dist/action.js

@@ -1,69 +1,99 @@
-import { useEidosStore as d } from "./store.js";
-import { getSwRegistration as b } from "./sw-bridge.js";
-import { idbClearQueue as g, idbRemoveFromQueue as Q, idbUpdateQueueItem as h, idbGetPendingItems as I, idbGetQueue as R, idbAddToQueue as k } from "./idb.js";
-import { _getQueueStorage as v } from "./queue-storage.js";
-const l = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), S = {
-  add: (e) => k(e),
-  getAll: () => R(),
-  getPending: () => I(),
-  update: (e, t) => h(e, t),
-  remove: (e) => Q(e),
-  clear: () => g()
-};
-function o() {
-  return v() ?? S;
+import { useEidosStore as y } from "./store.js";
+import { getSwRegistration as _ } from "./sw-bridge.js";
+import { idbQueueStorage as S } from "./idb.js";
+import { _getQueueStorage as M } from "./queue-storage.js";
+var h = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+function u() {
+  return M() ?? S;
 }
 function m() {
   return crypto.randomUUID();
 }
+function v(e, t, i) {
+  return e(...t, i);
+}
 function U(e, t) {
-  const r = t.name || e.name || m();
-  l.set(r, e), t.onRollback && f.set(r, t.onRollback), t.onConflict && y.set(r, t.onConflict);
-  const u = async (...a) => {
-    var i, s;
-    const { isOnline: n } = d.getState();
-    if ((i = t.onOptimistic) == null || i.call(t, ...a), t.reliability === "neverLose") {
-      if (!n)
-        return p(r, r, a, t);
-      try {
-        return await e(...a);
-      } catch {
-        return p(r, r, a, t);
-      }
+  const i = t.name || e.name || m(), a = t.namespace ? `${t.namespace}::${i}` : i;
+  h.set(a, e), x.set(a, t), t.onRollback && k.set(a, t.onRollback), t.onConflict && C.set(a, t.onConflict), t.conflict && Q.set(a, t.conflict);
+  const c = async (...n) => {
+    const { isOnline: s } = y.getState(), l = t.reliability === "neverLose" || t.cancellable, o = l ? m() : "";
+    let d;
+    if (t.cancellable) {
+      const f = new AbortController();
+      p.set(o, f), d = f.signal;
     }
+    const g = {
+      idempotencyKey: o,
+      attempt: 0,
+      signal: d
+    };
+    t.onOptimistic?.(...n, g);
     try {
-      return await e(...a);
-    } catch (w) {
-      throw (s = t.onRollback) == null || s.call(t, ...a), w;
+      if (t.reliability === "neverLose") {
+        if (!s) return R(a, a, n, t, o);
+        try {
+          return await v(e, n, g);
+        } catch (f) {
+          if (A(f)) throw f;
+          return R(a, a, n, t, o);
+        }
+      }
+      try {
+        return l ? await v(e, n, g) : await e(...n);
+      } catch (f) {
+        throw t.onRollback?.(...n), f;
+      }
+    } finally {
+      t.cancellable && p.delete(o);
     }
+  }, r = async (n) => {
+    const s = p.get(n);
+    if (s)
+      return s.abort(), !0;
+    const l = (await u().getAll()).find((o) => o.idempotencyKey === n && o.status === "pending");
+    return l ? (y.getState().removeQueueItem(l.id), await u().remove(l.id), !0) : !1;
   };
-  return Object.defineProperty(u, "id", { value: r, writable: !1 }), Object.defineProperty(u, "config", { value: t, writable: !1 }), u;
+  return Object.defineProperty(c, "id", {
+    value: a,
+    writable: !1
+  }), Object.defineProperty(c, "config", {
+    value: t,
+    writable: !1
+  }), Object.defineProperty(c, "cancel", {
+    value: r,
+    writable: !1
+  }), c;
 }
-async function p(e, t, r, u) {
-  const a = m(), n = {
-    id: a,
+async function R(e, t, i, a, c) {
+  const r = m(), n = {
+    schemaVersion: 2,
+    id: r,
     actionId: e,
     actionName: t,
-    args: r,
+    idempotencyKey: c,
+    args: i,
     queuedAt: Date.now(),
     retryCount: 0,
-    maxRetries: u.maxRetries ?? 3,
+    maxRetries: a.maxRetries ?? 3,
     status: "pending",
-    priority: u.priority ?? "normal"
+    priority: a.priority ?? "normal"
   };
-  await o().add(n), d.getState().addQueueItem(n);
+  await u().add(n), y.getState().addQueueItem(n);
   try {
-    const i = b();
-    i && "sync" in i && await i.sync.register("eidos-queue-replay");
+    const s = _();
+    s && "sync" in s && await s.sync.register("eidos-queue-replay");
   } catch {
   }
   return {
     queued: !0,
-    id: a,
+    id: r,
     message: `"${t}" queued — will execute when online`
   };
 }
-function x(e) {
+function A(e) {
+  return e instanceof DOMException && e.name === "AbortError";
+}
+function K(e) {
   if (e instanceof Response) return e.status >= 400 && e.status < 500;
   if (typeof e == "object" && e !== null) {
     const t = e.status;
@@ -71,76 +101,152 @@ function x(e) {
   }
   return !1;
 }
-function C(e) {
+function O(e) {
   return Math.min(2e3 * 2 ** e, 3e5) * (0.8 + Math.random() * 0.4);
 }
-let c = !1;
-async function j() {
-  const e = d.getState();
-  if (!e.isOnline || c)
-    return { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0, conflicted: 0 };
-  c = !0;
+function w() {
+  return {
+    attempted: 0,
+    succeeded: 0,
+    failed: 0,
+    retrying: 0,
+    skipped: 0,
+    conflicted: 0,
+    cancelled: 0
+  };
+}
+var b = !1, q = "eidos-queue-replay";
+async function $() {
+  const e = y.getState();
+  if (!e.isOnline) return w();
+  if (typeof navigator < "u" && navigator.locks) return navigator.locks.request(q, { ifAvailable: !0 }, async (t) => t ? I(e) : w());
+  if (b) return w();
+  b = !0;
   try {
-    return await M(e);
+    return await I(e);
   } finally {
-    c = !1;
+    b = !1;
   }
 }
-async function _(e, t) {
-  var u;
-  const r = l.get(e.actionId);
-  if (!r) return "skipped";
+async function E(e, t) {
+  const i = h.get(e.actionId);
+  if (!i) return "skipped";
+  const a = x.get(e.actionId)?.cancellable;
+  let c;
+  if (a) {
+    const n = new AbortController();
+    p.set(e.idempotencyKey, n), c = n.signal;
+  }
+  const r = {
+    idempotencyKey: e.idempotencyKey,
+    attempt: e.retryCount,
+    signal: c
+  };
   try {
-    await r(...e.args);
-    const a = Date.now();
-    return t.updateQueueItem(e.id, { status: "succeeded", completedAt: a }), await o().update(e.id, { status: "succeeded", completedAt: a }), setTimeout(() => {
-      t.removeQueueItem(e.id), o().remove(e.id);
+    await v(i, e.args, r);
+    const n = Date.now();
+    return t.updateQueueItem(e.id, {
+      status: "succeeded",
+      completedAt: n
+    }), await u().update(e.id, {
+      status: "succeeded",
+      completedAt: n
+    }), setTimeout(() => {
+      t.removeQueueItem(e.id), u().remove(e.id);
     }, 3e3), "succeeded";
-  } catch (a) {
-    if (x(a)) {
-      const i = y.get(e.actionId);
-      if (i && i(a, e.args) === "skip")
-        return t.removeQueueItem(e.id), await o().remove(e.id), "conflicted";
+  } catch (n) {
+    if (A(n))
+      return t.removeQueueItem(e.id), await u().remove(e.id), "cancelled";
+    if (K(n)) {
+      const l = Q.get(e.actionId);
+      let o;
+      if (l) switch (l.strategy) {
+        case "serverWins":
+          o = "skip";
+          break;
+        case "clientWins":
+        case "lastWriteWins":
+          o = "retry";
+          break;
+        case "merge":
+        case "custom": {
+          const d = {
+            error: n,
+            args: e.args,
+            attempt: e.retryCount,
+            idempotencyKey: e.idempotencyKey
+          };
+          o = l.resolve?.(d) ?? "retry";
+          break;
+        }
+      }
+      else {
+        const d = C.get(e.actionId);
+        d && (o = d(n, e.args));
+      }
+      if (o === "skip")
+        return t.removeQueueItem(e.id), await u().remove(e.id), "conflicted";
+      o && typeof o == "object" && (e.args = o.resolved, t.updateQueueItem(e.id, { args: o.resolved }), await u().update(e.id, { args: o.resolved }));
     }
-    const n = e.retryCount + 1;
-    if (n >= e.maxRetries)
-      return t.updateQueueItem(e.id, { status: "failed", error: String(a), retryCount: n }), await o().update(e.id, { status: "failed", error: String(a), retryCount: n }), (u = f.get(e.actionId)) == null || u(...e.args), "failed";
+    const s = e.retryCount + 1;
+    if (s >= e.maxRetries)
+      return t.updateQueueItem(e.id, {
+        status: "failed",
+        error: String(n),
+        retryCount: s
+      }), await u().update(e.id, {
+        status: "failed",
+        error: String(n),
+        retryCount: s
+      }), k.get(e.actionId)?.(...e.args), "failed";
     {
-      const i = Date.now() + C(n);
-      return t.updateQueueItem(e.id, { status: "pending", retryCount: n, nextRetryAt: i }), await o().update(e.id, { status: "pending", retryCount: n, nextRetryAt: i }), "retrying";
+      const l = Date.now() + O(s);
+      return t.updateQueueItem(e.id, {
+        status: "pending",
+        retryCount: s,
+        nextRetryAt: l
+      }), await u().update(e.id, {
+        status: "pending",
+        retryCount: s,
+        nextRetryAt: l
+      }), "retrying";
     }
+  } finally {
+    a && p.delete(e.idempotencyKey);
   }
 }
-async function A(e, t, r) {
+async function D(e, t, i) {
   if (e.length === 0) return;
-  const u = e.filter((n) => l.has(n.actionId));
-  if (r.skipped += e.length - u.length, u.length > 0) {
-    t.batchUpdateQueueItems(u.map((n) => ({ id: n.id, update: { status: "replaying" } })));
-    for (const n of u)
-      o().update(n.id, { status: "replaying" });
+  const a = e.filter((r) => h.has(r.actionId));
+  if (i.skipped += e.length - a.length, a.length > 0) {
+    t.batchUpdateQueueItems(a.map((r) => ({
+      id: r.id,
+      update: { status: "replaying" }
+    })));
+    for (const r of a) u().update(r.id, { status: "replaying" });
   }
-  const a = await Promise.allSettled(u.map((n) => _(n, t)));
-  for (const n of a) {
-    const i = n.status === "fulfilled" ? n.value : "failed";
-    i === "skipped" ? r.skipped++ : i === "conflicted" ? r.conflicted++ : (r.attempted++, r[i]++);
+  const c = await Promise.allSettled(a.map((r) => E(r, t)));
+  for (const r of c) {
+    const n = r.status === "fulfilled" ? r.value : "failed";
+    n === "skipped" ? i.skipped++ : n === "conflicted" ? i.conflicted++ : n === "cancelled" ? i.cancelled++ : (i.attempted++, i[n]++);
   }
 }
-async function M(e) {
-  const t = await o().getPending(), r = Date.now(), u = t.filter(
-    (n) => n.retryCount < n.maxRetries && (!n.nextRetryAt || n.nextRetryAt <= r)
-  ), a = { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0, conflicted: 0 };
-  for (const n of ["high", "normal", "low"]) {
-    const i = u.filter((s) => (s.priority ?? "normal") === n);
-    await A(i, e, a);
-  }
-  return a;
+async function I(e) {
+  const t = await u().getPending(), i = Date.now(), a = t.filter((r) => r.retryCount < r.maxRetries && (!r.nextRetryAt || r.nextRetryAt <= i)), c = w();
+  for (const r of [
+    "high",
+    "normal",
+    "low"
+  ]) await D(a.filter((n) => (n.priority ?? "normal") === r), e, c);
+  return c;
 }
 async function T() {
-  await o().clear(), d.getState().hydrateQueue([]);
+  await u().clear(), y.getState().hydrateQueue([]);
 }
 export {
   U as action,
   T as clearQueue,
-  j as replayQueue
+  $ as replayQueue
 };
-//# sourceMappingURL=action.js.map
+
+//# sourceMappingURL=action.js.map

package/dist/async-storage-adapter.js

@@ -1,5 +1,4 @@
-const i = "@eidos:queue";
-class l {
+var i = "@eidos:queue", l = class {
   constructor(t) {
     this.storage = t;
   }
@@ -15,28 +14,32 @@ class l {
     await this.storage.setItem(i, JSON.stringify(t));
   }
   async add(t) {
-    const e = await this.readAll();
-    e.push(t), await this.writeAll(e);
+    const a = await this.readAll();
+    a.push(t), await this.writeAll(a);
   }
   async getAll() {
     return this.readAll();
   }
   async getPending() {
-    return (await this.readAll()).filter((e) => e.status === "pending" || e.status === "failed");
+    return (await this.readAll()).filter((t) => t.status === "pending" || t.status === "failed");
   }
-  async update(t, e) {
-    const a = await this.readAll(), s = a.findIndex((r) => r.id === t);
-    s !== -1 && (a[s] = { ...a[s], ...e }), await this.writeAll(a);
+  async update(t, a) {
+    const e = await this.readAll(), s = e.findIndex((r) => r.id === t);
+    s !== -1 && (e[s] = {
+      ...e[s],
+      ...a
+    }), await this.writeAll(e);
   }
   async remove(t) {
-    const e = await this.readAll();
-    await this.writeAll(e.filter((a) => a.id !== t));
+    const a = await this.readAll();
+    await this.writeAll(a.filter((e) => e.id !== t));
   }
   async clear() {
     await this.storage.removeItem(i);
   }
-}
+};
 export {
   l as AsyncStorageQueueStorage
 };
-//# sourceMappingURL=async-storage-adapter.js.map
+
+//# sourceMappingURL=async-storage-adapter.js.map

package/dist/cli.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { generateKeyPairSync } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+//#region src/cli.ts
+var PUBLIC_KEY_NAME = "EIDOS_VAPID_PUBLIC_KEY";
+var PRIVATE_KEY_NAME = "EIDOS_VAPID_PRIVATE_KEY";
+function base64UrlFromBuffer(buf) {
+	return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBuffer(b64url) {
+	const b64 = (b64url + "=".repeat((4 - b64url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	return Buffer.from(b64, "base64");
+}
+/** Pads a base64url-encoded big-endian integer to `length` bytes (leading zeros). */
+function padTo(b64url, length) {
+	const buf = base64UrlToBuffer(b64url);
+	if (buf.length === length) return buf;
+	const padded = Buffer.alloc(length);
+	buf.copy(padded, length - buf.length);
+	return padded;
+}
+function generateVapidKeys() {
+	const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "prime256v1" });
+	const pubJwk = publicKey.export({ format: "jwk" });
+	const privJwk = privateKey.export({ format: "jwk" });
+	const x = padTo(pubJwk.x, 32);
+	const y = padTo(pubJwk.y, 32);
+	const point = Buffer.concat([
+		Buffer.from([4]),
+		x,
+		y
+	]);
+	const d = padTo(privJwk.d, 32);
+	return {
+		publicKey: base64UrlFromBuffer(point),
+		privateKey: base64UrlFromBuffer(d)
+	};
+}
+function detectEnvPrefix(cwd) {
+	if (existsSync(resolve(cwd, "next.config.js")) || existsSync(resolve(cwd, "next.config.ts"))) return "NEXT_PUBLIC_";
+	if (existsSync(resolve(cwd, "vite.config.ts")) || existsSync(resolve(cwd, "vite.config.js"))) return "VITE_";
+	if (existsSync(resolve(cwd, "svelte.config.js"))) return "PUBLIC_";
+	if (existsSync(resolve(cwd, "nuxt.config.ts")) || existsSync(resolve(cwd, "nuxt.config.js"))) return "NUXT_PUBLIC_";
+	return "";
+}
+function pickEnvFile(cwd) {
+	if (existsSync(resolve(cwd, ".env.local"))) return resolve(cwd, ".env.local");
+	if (existsSync(resolve(cwd, ".env"))) return resolve(cwd, ".env");
+	return resolve(cwd, ".env.local");
+}
+async function confirm(message) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const answer = await rl.question(`${message} (type "yes" to continue): `);
+	rl.close();
+	return answer.trim().toLowerCase() === "yes";
+}
+async function generateVapidKeysCommand() {
+	const cwd = process.cwd();
+	const publicKeyName = `${detectEnvPrefix(cwd)}${PUBLIC_KEY_NAME}`;
+	const force = process.argv.includes("--force");
+	const envFile = pickEnvFile(cwd);
+	const existing = existsSync(envFile) ? readFileSync(envFile, "utf8") : "";
+	const hasPublic = new RegExp(`^${publicKeyName}=`, "m").test(existing);
+	const hasPrivate = new RegExp(`^${PRIVATE_KEY_NAME}=`, "m").test(existing);
+	if (hasPublic && hasPrivate) {
+		if (!force) {
+			console.log(`VAPID keys already configured in ${envFile} — nothing to do.`);
+			console.log("Pass --force to regenerate (this invalidates ALL existing push subscriptions).");
+			return;
+		}
+		if (!await confirm(`⚠ Regenerating VAPID keys will invalidate ALL existing push subscriptions in ${envFile}. Continue?`)) {
+			console.log("Aborted.");
+			return;
+		}
+	}
+	const { publicKey, privateKey } = generateVapidKeys();
+	const lines = [`${publicKeyName}=${publicKey}`, `${PRIVATE_KEY_NAME}=${privateKey}`];
+	if (hasPublic && hasPrivate) writeFileSync(envFile, `${existing.split("\n").filter((line) => !line.startsWith(`${publicKeyName}=`) && !line.startsWith(`${PRIVATE_KEY_NAME}=`)).join("\n").replace(/\n+$/, "")}\n${lines.join("\n")}\n`);
+	else appendFileSync(envFile, `${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${lines.join("\n")}\n`);
+	console.log(`✓ VAPID keys written to ${envFile}`);
+	console.log("");
+	console.log(`  ${publicKeyName}=${publicKey}`);
+	console.log(`  ${PRIVATE_KEY_NAME}=${privateKey}`);
+	console.log("");
+	console.log(`Give ${PRIVATE_KEY_NAME} and ${publicKeyName} to your backend.`);
+	console.log("Backend needs a VAPID-capable web-push library (any language) to send notifications using subscription objects received via onSubscribe.");
+}
+var command = process.argv[2];
+switch (command) {
+	case "generate-vapid-keys":
+		await generateVapidKeysCommand();
+		break;
+	default:
+		console.log("Usage: eidos generate-vapid-keys [--force]");
+		process.exit(command ? 1 : 0);
+}
+//#endregion