@ebbjs/storage 0.0.0-stage → 0.1.0

package/dist/indexeddb/index.js

@@ -0,0 +1,335 @@
+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) => {
+  if (t.objectStoreNames.contains("actions"))
+    n.objectStore("actions").indexNames.contains("position") || n.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");
+  }
+  if (!t.objectStoreNames.contains("entities")) {
+    const s = t.createObjectStore("entities", { keyPath: "id" });
+    s.indexNames.contains("type") || s.createIndex("type", "type");
+  }
+  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");
+  }
+  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;
+  const s = e.openCursor();
+  s.onsuccess = () => {
+    const c = s.result;
+    if (c === null) {
+      a.put({ id: m, value: n });
+      return;
+    }
+    n += 1, c.update({ ...c.value, position: n }), c.continue();
+  };
+}, W = (t) => {
+  const e = /* @__PURE__ */ new Set();
+  for (const a of t.updates)
+    e.add(a.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) => ({
+  async append(e) {
+    const a = t.transaction(["actions", "sequence"], "readwrite"), n = await h(a, e);
+    return await a.done, n;
+  },
+  async appendMany(e) {
+    const a = t.transaction(["actions", "sequence"], "readwrite"), n = [];
+    for (const s of e)
+      n.push(await h(a, s));
+    return await a.done, n;
+  },
+  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),
+      position: s.position,
+      added: s.updates
+    }));
+  },
+  async lastPosition() {
+    return (await t.get("sequence", m))?.value ?? 0;
+  },
+  async getAll() {
+    return (await t.getAll("actions")).map(x);
+  },
+  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);
+  },
+  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;
+  }
+}), q = (t) => t === void 0 ? null : v(t), Z = (t) => {
+  const e = async (a) => q(await t.get("cursors", a));
+  return {
+    async get(a) {
+      return (await t.get("cursors", a))?.cursor ?? null;
+    },
+    async set(a, n) {
+      const s = await e(a);
+      await t.put("cursors", { groupId: a, ...s, cursor: n });
+    },
+    async getRecord(a) {
+      return e(a);
+    },
+    async setRecord(a, n) {
+      if (T(n)) {
+        await t.delete("cursors", a);
+        return;
+      }
+      await t.put("cursors", {
+        groupId: a,
+        ...v(n)
+      });
+    },
+    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;
+    },
+    async clear() {
+      await t.clear("cursors");
+    }
+  };
+}, $ = (t) => ({
+  async mark(e, a) {
+    await t.get("dirty", e) || await t.put("dirty", { entityId: e, entityType: a });
+  },
+  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);
+  },
+  async clear(e) {
+    await t.delete("dirty", e);
+  },
+  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);
+  };
+  return {
+    async get(o) {
+      await y(o);
+      const r = await t.get("entities", o);
+      return r ? n(r) : null;
+    },
+    async set(o) {
+      const r = await t.get("entities", o.id);
+      await t.put("entities", n(o)), await p(r, o);
+    },
+    async query(o) {
+      return await i(o), (await t.getAllFromIndex("entities", "type", o)).map(n);
+    },
+    async queryByRelationship({
+      as: o,
+      type: r,
+      targetId: u
+    }) {
+      return await i(I), d(U(o, r, u));
+    },
+    async queryByRelationshipSource({
+      as: o,
+      type: r,
+      sourceId: u
+    }) {
+      await i(I);
+      const w = await t.get("relationships", R(o, r, u));
+      return C(w?.rows);
+    },
+    async queryByMembership(o) {
+      return await i(j), d(K(o));
+    },
+    async queryByMembershipEntity(o) {
+      await i(j);
+      const r = await t.get("relationships", N(o));
+      return P(r?.rows);
+    },
+    async reset() {
+      await t.clear("relationships"), await t.clear("entities");
+    }
+  };
+}, E = (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) => ({
+  async put(e) {
+    await t.put("outbox", {
+      action: e.action,
+      status: e.status,
+      enqueuedAtHlc: e.enqueuedAtHlc,
+      basedOnGsn: e.basedOnGsn,
+      conflict: e.conflict
+    });
+  },
+  async putAndDelete(e, a) {
+    const n = t.transaction("outbox", "readwrite");
+    n.store.put({
+      action: e.action,
+      status: e.status,
+      enqueuedAtHlc: e.enqueuedAtHlc,
+      basedOnGsn: e.basedOnGsn,
+      conflict: e.conflict
+    }), n.store.delete(a), await n.done;
+  },
+  async list() {
+    return (await t.getAll("outbox")).map(E).sort((a, n) => V(a.enqueuedAtHlc, n.enqueuedAtHlc));
+  },
+  async get(e) {
+    const a = await t.get("outbox", e);
+    return a === void 0 ? null : E(a);
+  },
+  async delete(e) {
+    await t.delete("outbox", e);
+  },
+  async clear() {
+    await t.clear("outbox");
+  }
+}), at = (t) => ({
+  async load() {
+    const e = t.transaction(["replica", "replicaCursor"], "readonly"), a = await e.objectStore("replicaCursor").get(A);
+    if (a === void 0)
+      return await e.done, null;
+    const n = await e.objectStore("replica").getAll();
+    await e.done;
+    const s = {
+      format: a.format,
+      position: a.position,
+      revision: a.revision,
+      entities: n
+    };
+    return Y(s) ? s : null;
+  },
+  async save(e) {
+    const a = t.transaction(["replica", "replicaCursor"], "readwrite"), n = a.objectStore("replica");
+    await n.clear();
+    for (const s of e.entities)
+      await n.put(s);
+    await a.objectStore("replicaCursor").put({
+      id: A,
+      format: e.format,
+      position: e.position,
+      revision: e.revision
+    }), await a.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);
+  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 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 readTail(i) {
+        return n.readTail(i);
+      },
+      async lastPosition() {
+        return n.lastPosition();
+      },
+      async getAll() {
+        return n.getAll();
+      },
+      async getForEntity(i) {
+        return n.getForEntity(i);
+      },
+      async clear() {
+        await n.clear(), await s.clearAll(), await c.reset(), await y.clear();
+      }
+    },
+    entities: c,
+    dirtyTracker: {
+      async mark(i, d) {
+        await s.mark(i, d);
+      },
+      async isDirty(i) {
+        return s.isDirty(i);
+      },
+      async getDirtyForType(i) {
+        return s.getDirtyForType(i);
+      },
+      async clear(i) {
+        await s.clear(i);
+      },
+      async clearAll() {
+        await s.clearAll();
+      }
+    },
+    cursors: l,
+    outbox: p,
+    replica: y,
+    async isDirty(i) {
+      return s.isDirty(i);
+    },
+    async reset() {
+      await n.clear(), await s.clearAll(), await c.reset(), await y.clear(), await l.clear();
+    }
+  };
+};
+export {
+  it as createIndexedDBAdapter
+};