@ebbjs/storage 0.3.0 → 1.1.0

package/dist/indexeddb/index.js

@@ -1,121 +1,125 @@
-import { unwrap as _, openDB as b } from "idb";
-import { m as k, a as O, i as T, c as v } from "../cursor-record-D39emd6R.js";
-import { c as N, l as P, f as R, a as C, b as B, j as M, k as H, n as F, q as G, s as L, M as j, m as K, p as I, r as U, i as Y } from "../replica-record-D3lkFACh.js";
-import { compare as V } from "@ebbjs/core";
-const z = 8, m = "actionPosition", A = "replica", Q = (t, e, a, n) => {
+import { unwrap as D, openDB as O } from "idb";
+import { c as T, l as N, f as R, a as b, b as C, e as k, o as P, p as B, z as M, B as F, C as H, M as x, m as L, A as j, r as G, i as K, u as I } from "../replica-record-BaptWabD.js";
+import { m as U, a as V, i as Y, c as h } from "../cursor-record-D39emd6R.js";
+import { componentModel as z, compare as X } from "@ebbjs/core";
+const Q = 11, J = 9, W = 11, f = "actionPosition", A = "replica", Z = (t, e, o, a) => {
+  const s = [J, W], u = e > 0 && s.some((i) => e < i);
+  if (u)
+    for (const i of Array.from(t.objectStoreNames))
+      t.deleteObjectStore(i);
   if (t.objectStoreNames.contains("actions"))
-    n.objectStore("actions").indexNames.contains("position") || n.objectStore("actions").createIndex("position", "position");
+    a.objectStore("actions").indexNames.contains("position") || a.objectStore("actions").createIndex("position", "position");
   else {
-    const s = t.createObjectStore("actions", { keyPath: "id" });
-    s.createIndex("subject_id", "subject_ids", { multiEntry: !0 }), s.createIndex("position", "position");
+    const i = t.createObjectStore("actions", { keyPath: "id" });
+    i.createIndex("subject_id", "subject_ids", { multiEntry: !0 }), i.createIndex("position", "position");
   }
   if (!t.objectStoreNames.contains("entities")) {
-    const s = t.createObjectStore("entities", { keyPath: "id" });
-    s.indexNames.contains("type") || s.createIndex("type", "type");
+    const i = t.createObjectStore("entities", { keyPath: "id" });
+    i.indexNames.contains("type") || i.createIndex("type", "type"), i.createIndex("components", "components", { multiEntry: !0 });
   }
   if (t.objectStoreNames.contains("relationships") || t.createObjectStore("relationships", { keyPath: "key" }), !t.objectStoreNames.contains("dirty")) {
-    const s = t.createObjectStore("dirty", { keyPath: "entityId" });
-    s.indexNames.contains("entityType") || s.createIndex("entityType", "entityType");
+    const i = t.createObjectStore("dirty", { keyPath: "entityId" });
+    i.indexNames.contains("entityType") || i.createIndex("entityType", "entityType");
   }
-  t.objectStoreNames.contains("cursors") || t.createObjectStore("cursors", { keyPath: "groupId" }), t.objectStoreNames.contains("outbox") || t.createObjectStore("outbox", { keyPath: "action.id" }), t.objectStoreNames.contains("sequence") || t.createObjectStore("sequence", { keyPath: "id" }), t.objectStoreNames.contains("replica") || t.createObjectStore("replica", { keyPath: ["type", "id"] }), t.objectStoreNames.contains("replicaCursor") || t.createObjectStore("replicaCursor", { keyPath: "id" }), e < 8 && J(n);
-}, J = (t) => {
-  const e = _(t.objectStore("actions")), a = t.objectStore("sequence");
-  let n = 0;
+  t.objectStoreNames.contains("cursors") || t.createObjectStore("cursors", { keyPath: "groupId" }), t.objectStoreNames.contains("outbox") || t.createObjectStore("outbox", { keyPath: "action.id" }), t.objectStoreNames.contains("sequence") || t.createObjectStore("sequence", { keyPath: "id" }), t.objectStoreNames.contains("replica") || t.createObjectStore("replica", { keyPath: ["type", "id"] }), t.objectStoreNames.contains("replicaCursor") || t.createObjectStore("replicaCursor", { keyPath: "id" }), u ? a.objectStore("sequence").put({ id: f, value: 0 }) : e < 8 && $(a);
+}, $ = (t) => {
+  const e = D(t.objectStore("actions")), o = t.objectStore("sequence");
+  let a = 0;
   const s = e.openCursor();
   s.onsuccess = () => {
-    const c = s.result;
-    if (c === null) {
-      a.put({ id: m, value: n });
+    const u = s.result;
+    if (u === null) {
+      o.put({ id: f, value: a });
       return;
     }
-    n += 1, c.update({ ...c.value, position: n }), c.continue();
+    a += 1, u.update({ ...u.value, position: a }), u.continue();
   };
-}, W = (t) => {
+}, tt = (t) => {
   const e = /* @__PURE__ */ new Set();
-  for (const a of t.updates)
-    e.add(a.subject_id);
+  for (const o of t.updates)
+    e.add(o.subject_id);
   return Array.from(e);
-}, x = (t) => {
-  const { subject_ids: e, position: a, ...n } = t;
-  return n;
-}, h = async (t, e) => {
-  const a = t.objectStore("actions"), n = await a.get(e.id), s = await t.objectStore("sequence").get(m), c = n === void 0, l = c ? (s?.value ?? 0) + 1 : n.position, p = n === void 0 ? e : { ...e, updates: k(n.updates, e.updates) }, y = O(n?.updates ?? [], e.updates);
-  return await a.put({ ...p, position: l, subject_ids: W(p) }), c && await t.objectStore("sequence").put({ id: m, value: l }), { action: p, position: l, added: y };
-}, X = (t) => ({
+}, g = (t) => {
+  const { subject_ids: e, position: o, ...a } = t;
+  return a;
+}, E = async (t, e) => {
+  const o = t.objectStore("actions"), a = await o.get(e.id), s = await t.objectStore("sequence").get(f), u = a === void 0, i = u ? (s?.value ?? 0) + 1 : a.position, y = a === void 0 ? e : { ...e, updates: U(a.updates, e.updates) }, w = V(a?.updates ?? [], e.updates);
+  return await o.put({ ...y, position: i, subject_ids: tt(y) }), u && await t.objectStore("sequence").put({ id: f, value: i }), { action: y, position: i, added: w };
+}, et = (t) => ({
   async append(e) {
-    const a = t.transaction(["actions", "sequence"], "readwrite"), n = await h(a, e);
-    return await a.done, n;
+    const o = t.transaction(["actions", "sequence"], "readwrite"), a = await E(o, e);
+    return await o.done, a;
   },
   async appendMany(e) {
-    const a = t.transaction(["actions", "sequence"], "readwrite"), n = [];
+    const o = t.transaction(["actions", "sequence"], "readwrite"), a = [];
     for (const s of e)
-      n.push(await h(a, s));
-    return await a.done, n;
+      a.push(await E(o, s));
+    return await o.done, a;
   },
   async readTail(e) {
-    const a = t.transaction("actions", "readonly"), n = await a.store.index("position").getAll(IDBKeyRange.lowerBound(e, !0));
-    return await a.done, n.map((s) => ({
-      action: x(s),
+    const o = t.transaction("actions", "readonly"), a = await o.store.index("position").getAll(IDBKeyRange.lowerBound(e, !0));
+    return await o.done, a.map((s) => ({
+      action: g(s),
       position: s.position,
       added: s.updates
     }));
   },
   async lastPosition() {
-    return (await t.get("sequence", m))?.value ?? 0;
+    return (await t.get("sequence", f))?.value ?? 0;
   },
   async getAll() {
-    return (await t.getAll("actions")).map(x);
+    return (await t.getAll("actions")).map(g);
   },
   async getForEntity(e) {
-    const a = t.transaction("actions", "readonly"), n = await a.store.index("subject_id").getAll(e);
-    return await a.done, n.map(x).sort((c, l) => c.gsn - l.gsn);
+    const o = t.transaction("actions", "readonly"), a = await o.store.index("subject_id").getAll(e);
+    return await o.done, a.map(g).sort((u, i) => u.gsn - i.gsn);
   },
   async clear() {
     const e = t.transaction(["actions", "sequence"], "readwrite");
-    await e.objectStore("actions").clear(), await e.objectStore("sequence").put({ id: m, value: 0 }), await e.done;
+    await e.objectStore("actions").clear(), await e.objectStore("sequence").put({ id: f, value: 0 }), await e.done;
   }
-}), q = (t) => t === void 0 ? null : v(t), Z = (t) => {
-  const e = async (a) => q(await t.get("cursors", a));
+}), v = (t) => t === void 0 ? null : h(t), ot = (t) => {
+  const e = async (o) => v(await t.get("cursors", o));
   return {
-    async get(a) {
-      return (await t.get("cursors", a))?.cursor ?? null;
+    async get(o) {
+      return (await t.get("cursors", o))?.cursor ?? null;
     },
-    async set(a, n) {
-      const s = await e(a);
-      await t.put("cursors", { groupId: a, ...s, cursor: n });
+    async set(o, a) {
+      const s = await e(o);
+      await t.put("cursors", { groupId: o, ...s, cursor: a });
     },
-    async getRecord(a) {
-      return e(a);
+    async getRecord(o) {
+      return e(o);
     },
-    async setRecord(a, n) {
-      if (T(n)) {
-        await t.delete("cursors", a);
+    async setRecord(o, a) {
+      if (Y(a)) {
+        await t.delete("cursors", o);
         return;
       }
       await t.put("cursors", {
-        groupId: a,
-        ...v(n)
+        groupId: o,
+        ...h(a)
       });
     },
     async records() {
-      const a = await t.getAll("cursors"), n = /* @__PURE__ */ new Map();
-      for (const s of a)
-        n.set(s.groupId, q(s) ?? {});
-      return n;
+      const o = await t.getAll("cursors"), a = /* @__PURE__ */ new Map();
+      for (const s of o)
+        a.set(s.groupId, v(s) ?? {});
+      return a;
     },
     async clear() {
       await t.clear("cursors");
     }
   };
-}, $ = (t) => ({
-  async mark(e, a) {
-    await t.get("dirty", e) || await t.put("dirty", { entityId: e, entityType: a });
+}, at = (t) => ({
+  async mark(e, o) {
+    await t.get("dirty", e) || await t.put("dirty", { entityId: e, entityType: o });
   },
   async isDirty(e) {
     return await t.get("dirty", e) !== void 0;
   },
   async getDirtyForType(e) {
-    return (await t.getAllFromIndex("dirty", "entityType", e)).map((n) => n.entityId);
+    return (await t.getAllFromIndex("dirty", "entityType", e)).map((a) => a.entityId);
   },
   async clear(e) {
     await t.delete("dirty", e);
@@ -123,86 +127,99 @@ const z = 8, m = "actionPosition", A = "replica", Q = (t, e, a, n) => {
   async clearAll() {
     await t.clear("dirty");
   }
-}), tt = (t, e, a) => {
-  const n = (o) => structuredClone(o), s = async (o, r) => {
-    r === null ? await t.delete("relationships", o) : await t.put("relationships", { key: o, rows: r });
-  }, c = async (o) => {
-    const r = await t.get("relationships", o.key);
-    await s(o.key, L(r?.rows, o));
-  }, l = async (o) => {
-    const r = await t.get("relationships", o.key);
-    await s(o.key, G(r?.rows, o));
-  }, p = async (o, r) => {
-    for (const u of [M(o, r), H(o, r)])
-      u.remove !== null && await l(u.remove), u.add !== null && await c(u.add);
-  }, y = async (o) => {
-    if (!await a.isDirty(o)) return;
-    const u = await e.getForEntity(o);
-    if (u.length === 0) return;
-    let w = null;
-    for (const g of u)
-      for (const S of g.updates)
-        S.subject_id === o && (w = F(w, S, g.gsn, g.hlc));
-    if (w === null) return;
-    const D = await t.get("entities", o);
-    await t.put("entities", n(w)), await p(D, w), await a.clear(o);
-  }, i = async (o) => {
-    for (const r of await a.getDirtyForType(o))
-      await y(r);
-  }, d = async (o) => {
-    const r = await t.get("relationships", o);
-    return B(r?.rows);
+}), nt = (t, e, o) => {
+  const a = (n) => ({
+    ...structuredClone(n),
+    components: k(n)
+  }), s = (n) => {
+    const { components: r, ...l } = n;
+    return l;
+  }, u = async (n) => {
+    const r = await t.get("entities", n);
+    return r === void 0 ? void 0 : s(r);
+  }, i = async (n, r) => {
+    r === null ? await t.delete("relationships", n) : await t.put("relationships", { key: n, rows: r });
+  }, y = async (n) => {
+    const r = await t.get("relationships", n.key);
+    await i(n.key, H(r?.rows, n));
+  }, w = async (n) => {
+    const r = await t.get("relationships", n.key);
+    await i(n.key, F(r?.rows, n));
+  }, c = async (n, r) => {
+    for (const l of [P(n, r), B(n, r)])
+      l.remove !== null && await w(l.remove), l.add !== null && await y(l.add);
+  }, p = async (n) => {
+    if (!await o.isDirty(n)) return;
+    const l = await e.getForEntity(n);
+    if (l.length === 0) return;
+    const S = M(l, n);
+    if (S === null) return;
+    const q = await u(n);
+    await t.put("entities", a(S)), await c(q, S), await o.clear(n);
+  }, d = async (n) => {
+    for (const r of await o.getDirtyForType(n))
+      await p(r);
+  }, m = async (n) => {
+    const r = await t.get("relationships", n);
+    return C(r?.rows);
   };
   return {
-    async get(o) {
-      await y(o);
-      const r = await t.get("entities", o);
-      return r ? n(r) : null;
+    async get(n) {
+      await p(n);
+      const r = await t.get("entities", n);
+      return r === void 0 ? null : s(r);
+    },
+    async set(n) {
+      const r = await u(n.id);
+      await t.put("entities", a(n)), await c(r, n);
     },
-    async set(o) {
-      const r = await t.get("entities", o.id);
-      await t.put("entities", n(o)), await p(r, o);
+    async query(n) {
+      return await d(n), (await t.getAllFromIndex("entities", "type", n)).map(s);
     },
-    async query(o) {
-      return await i(o), (await t.getAllFromIndex("entities", "type", o)).map(n);
+    async queryByComponent(n) {
+      return await d(z(n)), (await t.getAllFromIndex("entities", "components", n)).filter((l) => l.deleted_hlc === null).map((l) => l.id).sort();
     },
     async queryByRelationship({
-      as: o,
+      as: n,
       type: r,
-      targetId: u
+      targetId: l
     }) {
-      return await i(I), d(U(o, r, u));
+      return await d(j), m(G(n, r, l));
     },
     async queryByRelationshipSource({
-      as: o,
+      as: n,
       type: r,
-      sourceId: u
+      sourceId: l
     }) {
-      await i(I);
-      const w = await t.get("relationships", R(o, r, u));
-      return C(w?.rows);
+      await d(j);
+      const S = await t.get("relationships", R(n, r, l));
+      return b(S?.rows);
     },
-    async queryByMembership(o) {
-      return await i(j), d(K(o));
+    async queryByMembership(n) {
+      return await d(x), m(L(n));
     },
-    async queryByMembershipEntity(o) {
-      await i(j);
-      const r = await t.get("relationships", N(o));
-      return P(r?.rows);
+    async queryByMembershipEntity(n) {
+      await d(x);
+      const r = await t.get("relationships", T(n));
+      return N(r?.rows);
     },
     async reset() {
       await t.clear("relationships"), await t.clear("entities");
     }
   };
-}, E = (t) => ({
+}, st = (t) => ({
+  ...t,
+  scope: t.scope ?? "field",
+  remoteActions: t.remoteActions ?? []
+}), _ = (t) => ({
   action: t.action,
   status: t.status,
   enqueuedAtHlc: t.enqueuedAtHlc,
   // A row predating the field reads as "always concurrent", never
   // silently dropped.
   basedOnGsn: t.basedOnGsn ?? 0,
-  conflict: t.conflict
-}), et = (t) => ({
+  conflict: t.conflict === void 0 ? void 0 : st(t.conflict)
+}), rt = (t) => ({
   async put(e) {
     await t.put("outbox", {
       action: e.action,
@@ -212,22 +229,22 @@ const z = 8, m = "actionPosition", A = "replica", Q = (t, e, a, n) => {
       conflict: e.conflict
     });
   },
-  async putAndDelete(e, a) {
-    const n = t.transaction("outbox", "readwrite");
-    n.store.put({
+  async putAndDelete(e, o) {
+    const a = t.transaction("outbox", "readwrite");
+    a.store.put({
       action: e.action,
       status: e.status,
       enqueuedAtHlc: e.enqueuedAtHlc,
       basedOnGsn: e.basedOnGsn,
       conflict: e.conflict
-    }), n.store.delete(a), await n.done;
+    }), a.store.delete(o), await a.done;
   },
   async list() {
-    return (await t.getAll("outbox")).map(E).sort((a, n) => V(a.enqueuedAtHlc, n.enqueuedAtHlc));
+    return (await t.getAll("outbox")).map(_).sort((o, a) => X(o.enqueuedAtHlc, a.enqueuedAtHlc));
   },
   async get(e) {
-    const a = await t.get("outbox", e);
-    return a === void 0 ? null : E(a);
+    const o = await t.get("outbox", e);
+    return o === void 0 ? null : _(o);
   },
   async delete(e) {
     await t.delete("outbox", e);
@@ -235,101 +252,107 @@ const z = 8, m = "actionPosition", A = "replica", Q = (t, e, a, n) => {
   async clear() {
     await t.clear("outbox");
   }
-}), at = (t) => ({
+}), it = (t) => ({
   async load() {
-    const e = t.transaction(["replica", "replicaCursor"], "readonly"), a = await e.objectStore("replicaCursor").get(A);
-    if (a === void 0)
+    const e = t.transaction(["replica", "replicaCursor"], "readonly"), o = await e.objectStore("replicaCursor").get(A);
+    if (o === void 0)
       return await e.done, null;
-    const n = await e.objectStore("replica").getAll();
+    const a = await e.objectStore("replica").getAll();
     await e.done;
     const s = {
-      format: a.format,
-      position: a.position,
-      revision: a.revision,
-      entities: n
+      format: o.format,
+      position: o.position,
+      revision: o.revision,
+      entities: a
     };
-    return Y(s) ? s : null;
+    return K(s) ? s : null;
   },
   async save(e) {
-    const a = t.transaction(["replica", "replicaCursor"], "readwrite"), n = a.objectStore("replica");
-    await n.clear();
+    const o = t.transaction(["replica", "replicaCursor"], "readwrite"), a = o.objectStore("replica");
+    await a.clear();
     for (const s of e.entities)
-      await n.put(s);
-    await a.objectStore("replicaCursor").put({
+      await a.put(s);
+    await o.objectStore("replicaCursor").put({
       id: A,
       format: e.format,
       position: e.position,
       revision: e.revision
-    }), await a.done;
+    }), await o.done;
   },
   async clear() {
     const e = t.transaction(["replica", "replicaCursor"], "readwrite");
     await e.objectStore("replica").clear(), await e.objectStore("replicaCursor").clear(), await e.done;
   }
-}), it = async (t = {}) => {
-  const e = t.dbName ?? "ebb-storage", a = await b(e, z, {
-    upgrade: Q
-  }), n = X(a), s = $(a), c = tt(a, n, s), l = Z(a), p = et(a), y = at(a);
+}), yt = async (t = {}) => {
+  const e = t.dbName ?? "ebb-storage", o = await O(e, Q, {
+    upgrade: Z
+  }), a = et(o), s = at(o), u = nt(o, a, s), i = ot(o), y = rt(o), w = it(o);
   return {
     actions: {
-      async append(i) {
-        const d = await n.append(i);
-        for (const f of i.updates)
-          await s.mark(f.subject_id, f.subject_type);
-        return d;
+      async append(c) {
+        const p = await a.append(c);
+        for (const d of c.updates)
+          await s.mark(
+            d.subject_id,
+            I(d, await u.get(d.subject_id))
+          );
+        return p;
       },
-      async appendMany(i) {
-        const d = await n.appendMany(i);
-        for (const f of i)
-          for (const o of f.updates)
-            await s.mark(o.subject_id, o.subject_type);
-        return d;
+      async appendMany(c) {
+        const p = await a.appendMany(c);
+        for (const d of c)
+          for (const m of d.updates)
+            await s.mark(
+              m.subject_id,
+              I(m, await u.get(m.subject_id))
+            );
+        return p;
       },
-      async readTail(i) {
-        return n.readTail(i);
+      async readTail(c) {
+        return a.readTail(c);
       },
       async lastPosition() {
-        return n.lastPosition();
+        return a.lastPosition();
       },
       async getAll() {
-        return n.getAll();
+        return a.getAll();
       },
-      async getForEntity(i) {
-        return n.getForEntity(i);
+      async getForEntity(c) {
+        return a.getForEntity(c);
       },
       async clear() {
-        await n.clear(), await s.clearAll(), await c.reset(), await y.clear();
+        await a.clear(), await s.clearAll(), await u.reset(), await w.clear();
       }
     },
-    entities: c,
+    entities: u,
     dirtyTracker: {
-      async mark(i, d) {
-        await s.mark(i, d);
+      async mark(c, p) {
+        await s.mark(c, p);
       },
-      async isDirty(i) {
-        return s.isDirty(i);
+      async isDirty(c) {
+        return s.isDirty(c);
       },
-      async getDirtyForType(i) {
-        return s.getDirtyForType(i);
+      async getDirtyForType(c) {
+        return s.getDirtyForType(c);
       },
-      async clear(i) {
-        await s.clear(i);
+      async clear(c) {
+        await s.clear(c);
       },
       async clearAll() {
         await s.clearAll();
       }
     },
-    cursors: l,
-    outbox: p,
-    replica: y,
-    async isDirty(i) {
-      return s.isDirty(i);
+    cursors: i,
+    outbox: y,
+    replica: w,
+    async isDirty(c) {
+      return s.isDirty(c);
     },
     async reset() {
-      await n.clear(), await s.clearAll(), await c.reset(), await y.clear(), await l.clear();
+      await a.clear(), await s.clearAll(), await u.reset(), await w.clear(), await i.clear();
     }
   };
 };
 export {
-  it as createIndexedDBAdapter
+  yt as createIndexedDBAdapter
 };