@typicalday/firegraph 0.8.0 → 0.10.0

package/dist/chunk-TYYPRVIE.js

@@ -0,0 +1,57 @@
+// src/scope-path.ts
+function parseStorageScope(scope) {
+  if (scope === "") return [];
+  const parts = scope.split("/");
+  if (parts.length % 2 !== 0) {
+    throw new Error(
+      `INVALID_SCOPE_PATH: storage-scope "${scope}" has an odd number of segments; expected interleaved <uid>/<name> pairs.`
+    );
+  }
+  const out = [];
+  for (let i = 0; i < parts.length; i += 2) {
+    const uid = parts[i];
+    const name = parts[i + 1];
+    if (!uid || !name) {
+      throw new Error(
+        `INVALID_SCOPE_PATH: storage-scope "${scope}" contains an empty segment at position ${i}.`
+      );
+    }
+    out.push({ uid, name });
+  }
+  return out;
+}
+function resolveAncestorScope(storageScope, uid) {
+  if (!uid) return null;
+  if (storageScope === "") return null;
+  const parts = storageScope.split("/");
+  for (let i = 0; i < parts.length; i += 2) {
+    if (parts[i] === uid) {
+      return i === 0 ? "" : parts.slice(0, i).join("/");
+    }
+  }
+  return null;
+}
+function isAncestorScopeUid(storageScope, uid) {
+  return resolveAncestorScope(storageScope, uid) !== null;
+}
+function appendStorageScope(parentScope, uid, name) {
+  if (!uid || uid.includes("/")) {
+    throw new Error(
+      `INVALID_SCOPE_PATH: uid must be non-empty and must not contain "/": got "${uid}".`
+    );
+  }
+  if (!name || name.includes("/")) {
+    throw new Error(
+      `INVALID_SCOPE_PATH: name must be non-empty and must not contain "/": got "${name}".`
+    );
+  }
+  return parentScope ? `${parentScope}/${uid}/${name}` : `${uid}/${name}`;
+}
+
+export {
+  parseStorageScope,
+  resolveAncestorScope,
+  isAncestorScopeUid,
+  appendStorageScope
+};
+//# sourceMappingURL=chunk-TYYPRVIE.js.map

package/dist/chunk-TYYPRVIE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/scope-path.ts"],"sourcesContent":["/**\n * Storage-scope path utilities — materialized-path parsing helpers for the\n * SQLite backend's `storageScope` string and for any custom backend that\n * adopts the same encoding (e.g. a cross-DO routing layer that uses\n * `storageScope` as a Durable Object name).\n *\n * **Storage-scope** (as produced by `SqliteBackendImpl`) interleaves parent\n * UIDs with subgraph names:\n *\n * ```\n * ''                                  // root\n * 'A/memories'                        // g.subgraph(A, 'memories')\n * 'A/memories/B/context'              // .subgraph(B, 'context') on the above\n * ```\n *\n * The structure is the same as a Firestore collection path with the\n * collection/doc segments reordered: each pair is `<uid>/<name>`, where\n * `<uid>` is a node UID in the parent scope and `<name>` is the subgraph\n * name. Use these helpers to decode that structure when building cross-\n * backend routers (see `createRoutingBackend`).\n *\n * For Firestore paths (which begin with a collection segment), use\n * `resolveAncestorCollection` / `isAncestorUid` from `./cross-graph.js`.\n */\n\n/**\n * One segment of a materialized-path storage-scope — a `(uid, name)` pair\n * produced by one `subgraph(uid, name)` call.\n */\nexport interface StorageScopeSegment {\n  /** Parent node UID at the enclosing scope. */\n  uid: string;\n  /** Subgraph name chosen by the caller (e.g. `'memories'`). */\n  name: string;\n}\n\n/**\n * Parse a materialized-path storage-scope into its `(uid, name)` pairs.\n *\n * Returns `[]` for the root (`''`). Throws `Error('INVALID_SCOPE_PATH')`\n * when the string has an odd number of segments (a corrupt path — every\n * level contributes exactly two segments) or when any segment is empty.\n *\n * @example\n * ```ts\n * parseStorageScope('');                         // []\n * parseStorageScope('A/memories');               // [{ uid: 'A', name: 'memories' }]\n * parseStorageScope('A/memories/B/context');     // [{ uid: 'A', name: 'memories' }, { uid: 'B', name: 'context' }]\n * ```\n */\nexport function parseStorageScope(scope: string): StorageScopeSegment[] {\n  if (scope === '') return [];\n  const parts = scope.split('/');\n  if (parts.length % 2 !== 0) {\n    throw new Error(\n      `INVALID_SCOPE_PATH: storage-scope \"${scope}\" has an odd number of segments; ` +\n        'expected interleaved <uid>/<name> pairs.',\n    );\n  }\n  const out: StorageScopeSegment[] = [];\n  for (let i = 0; i < parts.length; i += 2) {\n    const uid = parts[i];\n    const name = parts[i + 1];\n    if (!uid || !name) {\n      throw new Error(\n        `INVALID_SCOPE_PATH: storage-scope \"${scope}\" contains an empty segment at position ${i}.`,\n      );\n    }\n    out.push({ uid, name });\n  }\n  return out;\n}\n\n/**\n * Resolve the ancestor **storage-scope** at which a given UID's node lives,\n * by scanning a materialized-path storage-scope for that UID.\n *\n * Mirrors `resolveAncestorCollection()` from `./cross-graph.js` for\n * Firestore paths, but operates on `storageScope` (no leading collection\n * segment — segments are `<uid>/<name>` pairs).\n *\n * @returns The storage-scope at which the UID's node was added via\n *   `subgraph(uid, _)`, or `null` if the UID does not appear at a UID\n *   position in the path.\n *\n * @example\n * ```ts\n * // Scope: 'A/memories/B/context'\n * resolveAncestorScope('A/memories/B/context', 'A');  // ''    (A was added at root)\n * resolveAncestorScope('A/memories/B/context', 'B');  // 'A/memories'\n * resolveAncestorScope('A/memories/B/context', 'X');  // null\n * ```\n */\nexport function resolveAncestorScope(storageScope: string, uid: string): string | null {\n  if (!uid) return null;\n  if (storageScope === '') return null;\n  const parts = storageScope.split('/');\n  // UID positions are even indices (0, 2, 4, …); names are at odd indices.\n  for (let i = 0; i < parts.length; i += 2) {\n    if (parts[i] === uid) {\n      return i === 0 ? '' : parts.slice(0, i).join('/');\n    }\n  }\n  return null;\n}\n\n/**\n * Boolean shorthand for `resolveAncestorScope(scope, uid) !== null`.\n */\nexport function isAncestorScopeUid(storageScope: string, uid: string): boolean {\n  return resolveAncestorScope(storageScope, uid) !== null;\n}\n\n/**\n * Join a parent storage-scope with a new `(uid, name)` pair, producing the\n * storage-scope that `backend.subgraph(uid, name)` would use internally.\n *\n * This is the inverse of `parseStorageScope`'s per-segment semantics and is\n * useful when computing DO names / shard keys from the router callback.\n */\nexport function appendStorageScope(parentScope: string, uid: string, name: string): string {\n  if (!uid || uid.includes('/')) {\n    throw new Error(\n      `INVALID_SCOPE_PATH: uid must be non-empty and must not contain \"/\": got \"${uid}\".`,\n    );\n  }\n  if (!name || name.includes('/')) {\n    throw new Error(\n      `INVALID_SCOPE_PATH: name must be non-empty and must not contain \"/\": got \"${name}\".`,\n    );\n  }\n  return parentScope ? `${parentScope}/${uid}/${name}` : `${uid}/${name}`;\n}\n"],"mappings":";AAkDO,SAAS,kBAAkB,OAAsC;AACtE,MAAI,UAAU,GAAI,QAAO,CAAC;AAC1B,QAAM,QAAQ,MAAM,MAAM,GAAG;AAC7B,MAAI,MAAM,SAAS,MAAM,GAAG;AAC1B,UAAM,IAAI;AAAA,MACR,sCAAsC,KAAK;AAAA,IAE7C;AAAA,EACF;AACA,QAAM,MAA6B,CAAC;AACpC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACxC,UAAM,MAAM,MAAM,CAAC;AACnB,UAAM,OAAO,MAAM,IAAI,CAAC;AACxB,QAAI,CAAC,OAAO,CAAC,MAAM;AACjB,YAAM,IAAI;AAAA,QACR,sCAAsC,KAAK,2CAA2C,CAAC;AAAA,MACzF;AAAA,IACF;AACA,QAAI,KAAK,EAAE,KAAK,KAAK,CAAC;AAAA,EACxB;AACA,SAAO;AACT;AAsBO,SAAS,qBAAqB,cAAsB,KAA4B;AACrF,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI,iBAAiB,GAAI,QAAO;AAChC,QAAM,QAAQ,aAAa,MAAM,GAAG;AAEpC,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;AACxC,QAAI,MAAM,CAAC,MAAM,KAAK;AACpB,aAAO,MAAM,IAAI,KAAK,MAAM,MAAM,GAAG,CAAC,EAAE,KAAK,GAAG;AAAA,IAClD;AAAA,EACF;AACA,SAAO;AACT;AAKO,SAAS,mBAAmB,cAAsB,KAAsB;AAC7E,SAAO,qBAAqB,cAAc,GAAG,MAAM;AACrD;AASO,SAAS,mBAAmB,aAAqB,KAAa,MAAsB;AACzF,MAAI,CAAC,OAAO,IAAI,SAAS,GAAG,GAAG;AAC7B,UAAM,IAAI;AAAA,MACR,4EAA4E,GAAG;AAAA,IACjF;AAAA,EACF;AACA,MAAI,CAAC,QAAQ,KAAK,SAAS,GAAG,GAAG;AAC/B,UAAM,IAAI;AAAA,MACR,6EAA6E,IAAI;AAAA,IACnF;AAAA,EACF;AACA,SAAO,cAAc,GAAG,WAAW,IAAI,GAAG,IAAI,IAAI,KAAK,GAAG,GAAG,IAAI,IAAI;AACvE;","names":[]}