@typicalday/firegraph 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -159,6 +159,7 @@ var index_exports = {};
 __export(index_exports, {
   BOOTSTRAP_ENTRIES: () => BOOTSTRAP_ENTRIES,
   CrossBackendTransactionError: () => CrossBackendTransactionError,
+  DEFAULT_CORE_INDEXES: () => DEFAULT_CORE_INDEXES,
   DEFAULT_QUERY_LIMIT: () => DEFAULT_QUERY_LIMIT,
   DiscoveryError: () => DiscoveryError,
   DynamicRegistryError: () => DynamicRegistryError,
@@ -573,9 +574,7 @@ async function migrateRecord(record, registry, globalWriteBack = "off") {
   };
 }
 async function migrateRecords(records, registry, globalWriteBack = "off") {
-  return Promise.all(
-    records.map((r) => migrateRecord(r, registry, globalWriteBack))
-  );
+  return Promise.all(records.map((r) => migrateRecord(r, registry, globalWriteBack)));
 }
 
 // src/scope.ts
@@ -657,6 +656,28 @@ function createRegistry(input) {
   for (const [key, arr] of axbBuild) {
     axbIndex.set(key, Object.freeze(arr));
   }
+  const topologyIndex = /* @__PURE__ */ new Map();
+  const topologyBuild = /* @__PURE__ */ new Map();
+  const topologySeen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.targetGraph) continue;
+    let seen = topologySeen.get(entry.aType);
+    if (!seen) {
+      seen = /* @__PURE__ */ new Set();
+      topologySeen.set(entry.aType, seen);
+    }
+    if (seen.has(entry.targetGraph)) continue;
+    seen.add(entry.targetGraph);
+    const existing = topologyBuild.get(entry.aType);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      topologyBuild.set(entry.aType, [entry]);
+    }
+  }
+  for (const [key, arr] of topologyBuild) {
+    topologyIndex.set(key, Object.freeze(arr));
+  }
   return {
     lookup(aType, axbType, bType) {
       return map.get(tripleKey(aType, axbType, bType))?.entry;
@@ -664,6 +685,9 @@ function createRegistry(input) {
     lookupByAxbType(axbType) {
       return axbIndex.get(axbType) ?? [];
     },
+    getSubgraphTopology(aType) {
+      return topologyIndex.get(aType) ?? [];
+    },
     validate(aType, axbType, bType, data, scopePath) {
       const rec = map.get(tripleKey(aType, axbType, bType));
       if (!rec) {
@@ -711,6 +735,21 @@ function createMergedRegistry(base, extension) {
       }
       return Object.freeze(merged);
     },
+    getSubgraphTopology(aType) {
+      const baseResults = base.getSubgraphTopology(aType);
+      const extResults = extension.getSubgraphTopology(aType);
+      if (extResults.length === 0) return baseResults;
+      if (baseResults.length === 0) return extResults;
+      const seen = new Set(baseResults.map((e) => e.targetGraph));
+      const merged = [...baseResults];
+      for (const entry of extResults) {
+        if (!seen.has(entry.targetGraph)) {
+          seen.add(entry.targetGraph);
+          merged.push(entry);
+        }
+      }
+      return Object.freeze(merged);
+    },
     validate(aType, axbType, bType, data, scopePath) {
       if (baseKeys.has(tripleKey(aType, axbType, bType))) {
         return base.validate(aType, axbType, bType, data, scopePath);
@@ -743,7 +782,8 @@ function discoveryToEntries(discovery) {
       subtitleField: entity.subtitleField,
       allowedIn: entity.allowedIn,
       migrations: entity.migrations,
-      migrationWriteBack: entity.migrationWriteBack
+      migrationWriteBack: entity.migrationWriteBack,
+      indexes: entity.indexes
     });
   }
   for (const [axbType, entity] of discovery.edges) {
@@ -771,7 +811,8 @@ function discoveryToEntries(discovery) {
           allowedIn: entity.allowedIn,
           targetGraph: resolvedTargetGraph,
           migrations: entity.migrations,
-          migrationWriteBack: entity.migrationWriteBack
+          migrationWriteBack: entity.migrationWriteBack,
+          indexes: entity.indexes
         });
       }
     }
@@ -1443,6 +1484,21 @@ var GraphClientImpl = class _GraphClientImpl {
   getBackend() {
     return this.backend;
   }
+  /**
+   * Snapshot of the currently-effective registry. Returns the merged view
+   * used for domain-type validation and migration — in dynamic mode this is
+   * `dynamicRegistry ?? staticRegistry ?? bootstrapRegistry`, so callers see
+   * updates after `reloadRegistry()` without having to re-resolve anything.
+   *
+   * Exposed for backends that need topology access during bulk operations
+   * (e.g. the Cloudflare DO backend's cross-DO cascade). Not part of the
+   * public `GraphClient` surface.
+   *
+   * @internal
+   */
+  getRegistrySnapshot() {
+    return this.getCombinedRegistry();
+  }
   // ---------------------------------------------------------------------------
   // Registry routing
   // ---------------------------------------------------------------------------
@@ -1841,26 +1897,17 @@ function createGraphClientFromBackend(backend, options, metaBackend) {
 
 // src/codegen/index.ts
 function pascalCase(s) {
-  return s.replace(
-    /(^|[^a-zA-Z0-9])([a-zA-Z])/g,
-    (_, _sep, ch) => ch.toUpperCase()
-  );
+  return s.replace(/(^|[^a-zA-Z0-9])([a-zA-Z])/g, (_, _sep, ch) => ch.toUpperCase());
 }
 async function generateTypes(discovery, options = {}) {
   const { compile } = await import("json-schema-to-typescript");
   const { banner = true } = options;
   const chunks = [];
   if (banner) {
-    chunks.push(
-      "// Auto-generated by firegraph codegen \u2014 do not edit manually\n"
-    );
+    chunks.push("// Auto-generated by firegraph codegen \u2014 do not edit manually\n");
   }
-  const sortedNodes = [...discovery.nodes.entries()].sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  const sortedEdges = [...discovery.edges.entries()].sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
+  const sortedNodes = [...discovery.nodes.entries()].sort(([a], [b]) => a.localeCompare(b));
+  const sortedEdges = [...discovery.edges.entries()].sort(([a], [b]) => a.localeCompare(b));
   for (const [name, entity] of sortedNodes) {
     const typeName = `${pascalCase(name)}Data`;
     const ts = await compile(entity.schema, typeName, {
@@ -1915,6 +1962,18 @@ function isAncestorUid(collectionPath, uid) {
   return resolveAncestorCollection(collectionPath, uid) !== null;
 }
 
+// src/default-indexes.ts
+var DEFAULT_CORE_INDEXES = Object.freeze([
+  { fields: ["aUid"] },
+  { fields: ["bUid"] },
+  { fields: ["aType"] },
+  { fields: ["bType"] },
+  { fields: ["aUid", "axbType"] },
+  { fields: ["axbType", "bUid"] },
+  { fields: ["aType", "axbType"] },
+  { fields: ["axbType", "bType"] }
+]);
+
 // src/discover.ts
 var import_node_fs = require("fs");
 var import_node_module = require("module");
@@ -2036,7 +2095,8 @@ function loadNodeEntity(dir, name) {
     sampleData,
     allowedIn: meta?.allowedIn,
     migrations,
-    migrationWriteBack: meta?.migrationWriteBack
+    migrationWriteBack: meta?.migrationWriteBack,
+    indexes: meta?.indexes
   };
 }
 function loadEdgeEntity(dir, name) {
@@ -2073,7 +2133,8 @@ function loadEdgeEntity(dir, name) {
     allowedIn: meta?.allowedIn,
     targetGraph: topology.targetGraph ?? meta?.targetGraph,
     migrations,
-    migrationWriteBack: meta?.migrationWriteBack
+    migrationWriteBack: meta?.migrationWriteBack,
+    indexes: meta?.indexes
   };
 }
 function getSubdirectories(dir) {
@@ -2603,124 +2664,74 @@ function generateId() {
 }
 
 // src/indexes.ts
-function baseIndexes(collection) {
-  return [
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "aUid", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bUid", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "aType", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collection,
-      queryScope: "COLLECTION",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bType", order: "ASCENDING" }
-      ]
-    }
-  ];
+function normalizeField(f) {
+  return typeof f === "string" ? { path: f, desc: false } : { path: f.path, desc: !!f.desc };
 }
-function extractSchemaFields(schema) {
-  const s = schema;
-  if (s.type !== "object" || !s.properties) return [];
-  return Object.keys(s.properties);
-}
-function collectionGroupIndexes(collectionName) {
-  return [
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "aUid", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bUid", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "aType", order: "ASCENDING" },
-        { fieldPath: "axbType", order: "ASCENDING" }
-      ]
-    },
-    {
-      collectionGroup: collectionName,
-      queryScope: "COLLECTION_GROUP",
-      fields: [
-        { fieldPath: "axbType", order: "ASCENDING" },
-        { fieldPath: "bType", order: "ASCENDING" }
-      ]
-    }
-  ];
+function specFingerprint(spec, scope) {
+  const normalized = spec.fields.map(normalizeField);
+  return `${scope}::${JSON.stringify(normalized)}`;
 }
-function generateIndexConfig(collection, entities, registryEntries) {
-  const indexes = baseIndexes(collection);
-  if (entities) {
-    for (const [, entity] of entities.nodes) {
-      const fields = extractSchemaFields(entity.schema);
-      for (const field of fields) {
-        indexes.push({
-          collectionGroup: collection,
-          queryScope: "COLLECTION",
-          fields: [
-            { fieldPath: "aType", order: "ASCENDING" },
-            { fieldPath: "axbType", order: "ASCENDING" },
-            { fieldPath: `data.${field}`, order: "ASCENDING" }
-          ]
-        });
-      }
-    }
-    for (const [, entity] of entities.edges) {
-      const fields = extractSchemaFields(entity.schema);
-      for (const field of fields) {
-        indexes.push({
-          collectionGroup: collection,
-          queryScope: "COLLECTION",
-          fields: [
-            { fieldPath: "aUid", order: "ASCENDING" },
-            { fieldPath: "axbType", order: "ASCENDING" },
-            { fieldPath: `data.${field}`, order: "ASCENDING" }
-          ]
-        });
-      }
+function toFirestoreFields(spec) {
+  return spec.fields.map((f) => {
+    const n = normalizeField(f);
+    return {
+      fieldPath: n.path,
+      order: n.desc ? "DESCENDING" : "ASCENDING"
+    };
+  });
+}
+var warnedOnPartialIndex = false;
+function generateIndexConfig(collection, options = {}) {
+  const core = options.coreIndexes ?? [...DEFAULT_CORE_INDEXES];
+  const fromEntries = (options.registryEntries ?? []).flatMap((e) => {
+    if (!e.indexes) return [];
+    return e.indexes;
+  });
+  const targetGraphNames = /* @__PURE__ */ new Set();
+  for (const entry of options.registryEntries ?? []) {
+    if (entry.targetGraph) targetGraphNames.add(entry.targetGraph);
+  }
+  if (options.entities) {
+    for (const [, entity] of options.entities.edges) {
+      const tg = entity.targetGraph ?? entity.topology?.targetGraph;
+      if (tg) targetGraphNames.add(tg);
     }
   }
-  if (registryEntries) {
-    const targetGraphNames = /* @__PURE__ */ new Set();
-    for (const entry of registryEntries) {
-      if (entry.targetGraph) {
-        targetGraphNames.add(entry.targetGraph);
+  const allSpecs = [...core, ...fromEntries];
+  const seen = /* @__PURE__ */ new Set();
+  const indexes = [];
+  for (const spec of allSpecs) {
+    if (!spec.fields || spec.fields.length < 2) {
+      continue;
+    }
+    if (spec.where) {
+      if (!warnedOnPartialIndex) {
+        warnedOnPartialIndex = true;
+        console.warn(
+          "firegraph: IndexSpec.where is ignored by the Firestore generator \u2014 Firestore composite indexes do not support predicates. The SQLite backends will still honor `where`."
+        );
       }
+      continue;
+    }
+    const fields = toFirestoreFields(spec);
+    const colKey = specFingerprint(spec, `col:${collection}`);
+    if (!seen.has(colKey)) {
+      seen.add(colKey);
+      indexes.push({
+        collectionGroup: collection,
+        queryScope: "COLLECTION",
+        fields
+      });
     }
-    for (const name of targetGraphNames) {
-      indexes.push(...collectionGroupIndexes(name));
+    for (const tg of targetGraphNames) {
+      const cgKey = specFingerprint(spec, `cg:${tg}`);
+      if (seen.has(cgKey)) continue;
+      seen.add(cgKey);
+      indexes.push({
+        collectionGroup: tg,
+        queryScope: "COLLECTION_GROUP",
+        fields
+      });
     }
   }
   return { indexes, fieldOverrides: [] };
@@ -3378,6 +3389,7 @@ function defineViews(input) {
 0 && (module.exports = {
   BOOTSTRAP_ENTRIES,
   CrossBackendTransactionError,
+  DEFAULT_CORE_INDEXES,
   DEFAULT_QUERY_LIMIT,
   DiscoveryError,
   DynamicRegistryError,