@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/chunk-M3WP7RQZ.js

@@ -0,0 +1,736 @@
+import { rowPropsToObject } from './chunk-AKLS3BYZ.js';
+import { checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck } from './chunk-WDGA7IYB.js';
+import { typeGraphGlobalSymbol } from './chunk-PQBQG7IM.js';
+import { resolveEmbeddingFields, getSearchableFields, DEFAULT_SEARCHABLE_LANGUAGE } from './chunk-PC2UBAUB.js';
+import { UniquenessError, RestrictedDeleteError } from './chunk-J3WZ3FA2.js';
+import { readOwnProperty } from './chunk-DYATYRY4.js';
+
+// src/store/types.ts
+var AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1e3;
+var TRANSACTION_RUNTIME = typeGraphGlobalSymbol(
+  "transaction-runtime-v1"
+);
+
+// src/store/runtime-port.ts
+var STORE_RUNTIME = typeGraphGlobalSymbol("store-runtime-v1");
+function storeRuntime(store) {
+  const runtime = store[STORE_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this Store's runtime port. The Store may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime;
+}
+function storeBackend(store) {
+  return storeRuntime(store).backend;
+}
+function transactionBackend(transaction) {
+  const runtime = transaction[TRANSACTION_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime.backend;
+}
+function transactionNodeOperationHookRunner(transaction) {
+  const runtime = transaction[TRANSACTION_RUNTIME];
+  if (runtime === void 0) {
+    throw new TypeError(
+      "Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version."
+    );
+  }
+  return runtime.runNodeOperationHooks;
+}
+
+// src/store/embedding-sync.ts
+var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
+function getEmbeddingFields(schema) {
+  const cached = embeddingFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = resolveEmbeddingFields(schema);
+  embeddingFieldsCache.set(schema, fields);
+  return fields;
+}
+async function syncEmbeddings(ctx, schema, props) {
+  const { backend } = ctx;
+  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    const value = readOwnProperty(props, field.fieldPath);
+    if (isValidEmbeddingValue(value)) {
+      await backend.upsertEmbedding({
+        graphId: ctx.graphId,
+        nodeKind: ctx.nodeKind,
+        nodeId: ctx.nodeId,
+        fieldPath: field.fieldPath,
+        embedding: value,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    } else if (value === void 0) {
+      await backend.deleteEmbedding({
+        graphId: ctx.graphId,
+        nodeKind: ctx.nodeKind,
+        nodeId: ctx.nodeId,
+        fieldPath: field.fieldPath,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    }
+  }
+}
+async function syncEmbeddingsBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    const rows = [];
+    const deletionIds = [];
+    for (const item of items) {
+      const value = readOwnProperty(item.props, field.fieldPath);
+      if (isValidEmbeddingValue(value)) {
+        rows.push({ nodeId: item.nodeId, embedding: value });
+      } else if (value === void 0) {
+        deletionIds.push(item.nodeId);
+      }
+    }
+    if (rows.length > 0) {
+      if (backend.upsertEmbeddingBatch === void 0) {
+        for (const row of rows) {
+          await backend.upsertEmbedding({
+            graphId,
+            nodeKind,
+            nodeId: row.nodeId,
+            fieldPath: field.fieldPath,
+            embedding: row.embedding,
+            dimensions: field.dimensions,
+            metric: field.metric,
+            indexType: field.indexType
+          });
+        }
+      } else {
+        await backend.upsertEmbeddingBatch({
+          graphId,
+          nodeKind,
+          fieldPath: field.fieldPath,
+          dimensions: field.dimensions,
+          metric: field.metric,
+          indexType: field.indexType,
+          rows
+        });
+      }
+    }
+    if (deletionIds.length > 0 && backend.deleteEmbeddingBatch !== void 0) {
+      await backend.deleteEmbeddingBatch({
+        graphId,
+        nodeKind,
+        nodeIds: deletionIds,
+        fieldPath: field.fieldPath,
+        dimensions: field.dimensions,
+        metric: field.metric,
+        indexType: field.indexType
+      });
+    } else {
+      for (const nodeId of deletionIds) {
+        await backend.deleteEmbedding({
+          graphId,
+          nodeKind,
+          nodeId,
+          fieldPath: field.fieldPath,
+          dimensions: field.dimensions,
+          metric: field.metric,
+          indexType: field.indexType
+        });
+      }
+    }
+  }
+}
+async function deleteNodeEmbeddings(ctx, schema) {
+  const { backend } = ctx;
+  if (!backend.deleteEmbedding) {
+    return;
+  }
+  const embeddingFields = getEmbeddingFields(schema);
+  if (embeddingFields.length === 0) {
+    return;
+  }
+  for (const field of embeddingFields) {
+    await backend.deleteEmbedding({
+      graphId: ctx.graphId,
+      nodeKind: ctx.nodeKind,
+      nodeId: ctx.nodeId,
+      fieldPath: field.fieldPath,
+      dimensions: field.dimensions,
+      metric: field.metric,
+      indexType: field.indexType
+    });
+  }
+}
+function isValidEmbeddingValue(value) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  return value.every((n) => typeof n === "number" && Number.isFinite(n));
+}
+
+// src/store/fulltext-sync.ts
+var FIELD_SEPARATOR = "\n";
+function resolveCombinedLanguage(fields) {
+  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;
+}
+function computeFulltextContent(schema, props) {
+  const searchableFields = getSearchableFields(schema);
+  if (searchableFields.length === 0) return void 0;
+  const parts = [];
+  for (const field of searchableFields) {
+    const value = readOwnProperty(props, field.fieldPath);
+    if (typeof value === "string" && value.length > 0) {
+      parts.push(value);
+    }
+  }
+  if (parts.length === 0) return void 0;
+  return {
+    content: parts.join(FIELD_SEPARATOR),
+    language: resolveCombinedLanguage(searchableFields)
+  };
+}
+async function syncFulltext(ctx, schema, props) {
+  const { backend } = ctx;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const computed = computeFulltextContent(schema, props);
+  if (computed !== void 0) {
+    await backend.upsertFulltext({
+      graphId: ctx.graphId,
+      nodeKind: ctx.nodeKind,
+      nodeId: ctx.nodeId,
+      content: computed.content,
+      language: computed.language
+    });
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) return;
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+async function syncFulltextBatchForKind(args, schema, items) {
+  const { graphId, nodeKind, backend } = args;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const rows = [];
+  const emptyContentIds = [];
+  const hasSearchableFields = getSearchableFields(schema).length > 0;
+  for (const item of items) {
+    const computed = computeFulltextContent(schema, item.props);
+    if (computed !== void 0) {
+      rows.push({
+        nodeId: item.nodeId,
+        content: computed.content,
+        language: computed.language
+      });
+    } else if (hasSearchableFields) {
+      emptyContentIds.push(item.nodeId);
+    }
+  }
+  if (rows.length > 0) {
+    if (backend.upsertFulltextBatch === void 0) {
+      for (const row of rows) {
+        await backend.upsertFulltext({
+          graphId,
+          nodeKind,
+          nodeId: row.nodeId,
+          content: row.content,
+          language: row.language
+        });
+      }
+    } else {
+      await backend.upsertFulltextBatch({ graphId, nodeKind, rows });
+    }
+  }
+  if (emptyContentIds.length > 0) {
+    if (backend.deleteFulltextBatch === void 0) {
+      for (const nodeId of emptyContentIds) {
+        await backend.deleteFulltext({ graphId, nodeKind, nodeId });
+      }
+    } else {
+      await backend.deleteFulltextBatch({
+        graphId,
+        nodeKind,
+        nodeIds: emptyContentIds
+      });
+    }
+  }
+}
+async function deleteNodeFulltext(ctx, schema) {
+  const { backend } = ctx;
+  if (!backend.deleteFulltext) {
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) {
+    return;
+  }
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+
+// src/store/uniqueness.ts
+function createUniquenessContext(graphId, registry, backend) {
+  return { graphId, registry, backend };
+}
+async function probeUniqueKey(ctx, kind, id, constraint, key) {
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  let heldByThisNode = false;
+  for (const kindToCheck of kindsToCheck) {
+    const existing = await ctx.backend.checkUnique({
+      graphId: ctx.graphId,
+      nodeKind: kindToCheck,
+      constraintName: constraint.name,
+      key
+    });
+    if (existing === void 0) continue;
+    if (existing.node_id !== id) {
+      throw new UniquenessError({
+        constraintName: constraint.name,
+        kind: kindToCheck,
+        existingId: existing.node_id,
+        newId: id,
+        fields: constraint.fields
+      });
+    }
+    if (kindToCheck === kind) heldByThisNode = true;
+  }
+  return heldByThisNode;
+}
+async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    await probeUniqueKey(
+      ctx,
+      kind,
+      id,
+      constraint,
+      computeUniqueKey(props, constraint.fields, constraint.collation)
+    );
+  }
+}
+async function insertUniquenessEntries(ctx, kind, id, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    await ctx.backend.insertUnique({
+      graphId: ctx.graphId,
+      nodeKind: kind,
+      constraintName: constraint.name,
+      key,
+      nodeId: id,
+      concreteKind: kind
+    });
+  }
+}
+async function insertUniquenessEntriesBatch(ctx, items) {
+  const entries = [];
+  for (const item of items) {
+    for (const constraint of item.constraints) {
+      if (!checkWherePredicate(constraint, item.props)) {
+        continue;
+      }
+      entries.push({
+        graphId: ctx.graphId,
+        nodeKind: item.kind,
+        constraintName: constraint.name,
+        key: computeUniqueKey(
+          item.props,
+          constraint.fields,
+          constraint.collation
+        ),
+        nodeId: item.id,
+        concreteKind: item.kind
+      });
+    }
+  }
+  if (entries.length === 0) return;
+  if (ctx.backend.insertUniqueBatch !== void 0) {
+    await ctx.backend.insertUniqueBatch(entries);
+    return;
+  }
+  for (const entry of entries) {
+    await ctx.backend.insertUnique(entry);
+  }
+}
+async function deleteUniquenessEntries(ctx, kind, props, constraints) {
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) {
+      continue;
+    }
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    await ctx.backend.deleteUnique({
+      graphId: ctx.graphId,
+      nodeKind: kind,
+      constraintName: constraint.name,
+      key
+    });
+  }
+}
+async function planUniquenessUpdate(ctx, kind, id, oldProps, newProps, constraints) {
+  const pending = [];
+  for (const constraint of constraints) {
+    const oldApplies = checkWherePredicate(constraint, oldProps);
+    const newApplies = checkWherePredicate(constraint, newProps);
+    const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
+    const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
+    if (!oldApplies && !newApplies) {
+      continue;
+    }
+    if (oldApplies && newApplies && oldKey === newKey) {
+      continue;
+    }
+    const alreadyHeld = newKey === void 0 ? false : await probeUniqueKey(ctx, kind, id, constraint, newKey);
+    pending.push({
+      constraintName: constraint.name,
+      release: oldKey,
+      claim: alreadyHeld ? void 0 : newKey
+    });
+  }
+  return pending;
+}
+async function planUniquenessReinsert(ctx, kind, id, props, constraints) {
+  const pending = [];
+  for (const constraint of constraints) {
+    if (!checkWherePredicate(constraint, props)) continue;
+    const key = computeUniqueKey(
+      props,
+      constraint.fields,
+      constraint.collation
+    );
+    const alreadyHeld = await probeUniqueKey(ctx, kind, id, constraint, key);
+    pending.push({
+      constraintName: constraint.name,
+      release: void 0,
+      claim: alreadyHeld ? void 0 : key
+    });
+  }
+  return pending;
+}
+async function releaseUniqueKeys(ctx, kind, keys) {
+  for (const entry of keys) {
+    await ctx.backend.deleteUnique({
+      graphId: ctx.graphId,
+      nodeKind: kind,
+      constraintName: entry.constraintName,
+      key: entry.key
+    });
+  }
+}
+async function claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite) {
+  const claimed = [];
+  try {
+    for (const mutation of plan) {
+      if (mutation.claim === void 0) continue;
+      await ctx.backend.insertUnique({
+        graphId: ctx.graphId,
+        nodeKind: kind,
+        constraintName: mutation.constraintName,
+        key: mutation.claim,
+        nodeId: id,
+        concreteKind: kind
+      });
+      claimed.push({
+        constraintName: mutation.constraintName,
+        key: mutation.claim
+      });
+    }
+    return await gatedWrite();
+  } catch (error) {
+    await releaseUniqueKeys(ctx, kind, claimed);
+    throw error;
+  }
+}
+async function withUniquenessTransition(ctx, kind, id, plan, gatedWrite) {
+  const result = await claimUniqueKeysThen(ctx, kind, id, plan, gatedWrite);
+  await releaseUniqueKeys(
+    ctx,
+    kind,
+    plan.flatMap(
+      (mutation) => mutation.release === void 0 ? [] : [{ constraintName: mutation.constraintName, key: mutation.release }]
+    )
+  );
+  return result;
+}
+
+// src/store/operations/node-write-pipeline.ts
+function createNodeWriteContext(graphId, registry, lock) {
+  return { graphId, registry, lock };
+}
+function uniquenessContext(ctx, backend) {
+  return createUniquenessContext(ctx.graphId, ctx.registry, backend);
+}
+function nodeSyncContext(ctx, kind, id, backend) {
+  return { graphId: ctx.graphId, nodeKind: kind, nodeId: id, backend };
+}
+async function enforceNodeDeleteBehavior(ctx, args, backend, policy) {
+  if (policy?.enforceDeleteBehavior === false) return;
+  const behavior = args.onDelete ?? "restrict";
+  const connectedEdges = await backend.findEdgesConnectedTo({
+    graphId: ctx.graphId,
+    nodeKind: args.kind,
+    nodeId: args.id
+  });
+  if (connectedEdges.length === 0) return;
+  switch (behavior) {
+    case "restrict": {
+      throw new RestrictedDeleteError({
+        nodeKind: args.kind,
+        nodeId: args.id,
+        edgeCount: connectedEdges.length,
+        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))]
+      });
+    }
+    case "cascade":
+    case "disconnect": {
+      const batchDelete = args.mode === "hard" ? backend.hardDeleteEdgesBatch : backend.deleteEdgesBatch;
+      if (batchDelete !== void 0) {
+        await batchDelete({
+          graphId: ctx.graphId,
+          ids: connectedEdges.map((edge) => edge.id)
+        });
+        break;
+      }
+      for (const edge of connectedEdges) {
+        await (args.mode === "hard" ? backend.hardDeleteEdge({ graphId: ctx.graphId, id: edge.id }) : backend.deleteEdge({ graphId: ctx.graphId, id: edge.id }));
+      }
+      break;
+    }
+  }
+}
+async function applyNodeInsertSideEffects(ctx, args, backend) {
+  await insertUniquenessEntries(
+    uniquenessContext(ctx, backend),
+    args.kind,
+    args.id,
+    args.props,
+    args.uniqueConstraints
+  );
+  await Promise.all([
+    syncEmbeddings(
+      nodeSyncContext(ctx, args.kind, args.id, backend),
+      args.schema,
+      args.props
+    ),
+    syncFulltext(
+      nodeSyncContext(ctx, args.kind, args.id, backend),
+      args.schema,
+      args.props
+    )
+  ]);
+}
+async function applyNodeInsertSideEffectsBatch(ctx, items, backend) {
+  if (items.length === 0) return;
+  await insertUniquenessEntriesBatch(
+    uniquenessContext(ctx, backend),
+    items.map((item) => ({
+      kind: item.kind,
+      id: item.id,
+      props: item.props,
+      constraints: item.uniqueConstraints
+    }))
+  );
+  const byKind = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const group = byKind.get(item.kind) ?? { schema: item.schema, rows: [] };
+    group.rows.push({ nodeId: item.id, props: item.props });
+    byKind.set(item.kind, group);
+  }
+  await Promise.all(
+    [...byKind.entries()].flatMap(([kind, group]) => {
+      const syncArguments = { graphId: ctx.graphId, nodeKind: kind, backend };
+      return [
+        syncEmbeddingsBatchForKind(syncArguments, group.schema, group.rows),
+        syncFulltextBatchForKind(syncArguments, group.schema, group.rows)
+      ];
+    })
+  );
+}
+function parseRowProps(row) {
+  return rowPropsToObject(row.props);
+}
+async function planNodeUpdateUniqueness(ctx, args, backend) {
+  const { kind, id } = args.existing;
+  if (args.existing.deleted_at !== void 0) {
+    return planUniquenessReinsert(
+      uniquenessContext(ctx, backend),
+      kind,
+      id,
+      args.validatedProps,
+      args.uniqueConstraints
+    );
+  }
+  return planUniquenessUpdate(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    parseRowProps(args.existing),
+    args.validatedProps,
+    args.uniqueConstraints
+  );
+}
+async function applyNodeUpdate(ctx, args, backend) {
+  const { kind, id } = args.existing;
+  const plan = await planNodeUpdateUniqueness(
+    ctx,
+    {
+      existing: args.existing,
+      validatedProps: args.validatedProps,
+      uniqueConstraints: args.uniqueConstraints
+    },
+    backend
+  );
+  const updateParams = {
+    graphId: ctx.graphId,
+    kind,
+    id,
+    props: args.validatedProps,
+    incrementVersion: true
+  };
+  if (args.validFrom !== void 0) updateParams.validFrom = args.validFrom;
+  if (args.validTo !== void 0) updateParams.validTo = args.validTo;
+  if (args.expectedValidFrom !== void 0) {
+    updateParams.expectedValidFrom = args.expectedValidFrom;
+  }
+  if (args.clearDeleted) updateParams.clearDeleted = true;
+  const row = await withUniquenessTransition(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    plan,
+    () => backend.updateNode(updateParams)
+  );
+  await Promise.all([
+    syncEmbeddings(
+      nodeSyncContext(ctx, kind, id, backend),
+      args.schema,
+      args.validatedProps
+    ),
+    syncFulltext(
+      nodeSyncContext(ctx, kind, id, backend),
+      args.schema,
+      args.validatedProps
+    )
+  ]);
+  return row;
+}
+async function applyNodeSoftDelete(ctx, args, backend, policy) {
+  const { kind, id } = args.existing;
+  await enforceNodeDeleteBehavior(
+    ctx,
+    { kind, id, mode: "soft", onDelete: args.onDelete },
+    backend,
+    policy
+  );
+  await backend.deleteNode({
+    graphId: ctx.graphId,
+    kind,
+    id
+  });
+  await deleteUniquenessEntries(
+    uniquenessContext(ctx, backend),
+    kind,
+    parseRowProps(args.existing),
+    args.uniqueConstraints
+  );
+  await deleteNodeEmbeddings(
+    nodeSyncContext(ctx, kind, id, backend),
+    args.schema
+  );
+  await deleteNodeFulltext(
+    nodeSyncContext(ctx, kind, id, backend),
+    args.schema
+  );
+}
+async function applyNodeHardDelete(ctx, args, backend) {
+  await enforceNodeDeleteBehavior(
+    ctx,
+    { kind: args.kind, id: args.id, mode: "hard", onDelete: args.onDelete },
+    backend
+  );
+  await backend.hardDeleteNode({
+    graphId: ctx.graphId,
+    kind: args.kind,
+    id: args.id
+  });
+  await deleteNodeEmbeddings(
+    nodeSyncContext(ctx, args.kind, args.id, backend),
+    args.schema
+  );
+}
+async function applyNodeResurrect(ctx, args, backend) {
+  const { kind, id } = args.existing;
+  const props = parseRowProps(args.existing);
+  const plan = await planUniquenessReinsert(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    props,
+    args.uniqueConstraints
+  );
+  const row = await withUniquenessTransition(
+    uniquenessContext(ctx, backend),
+    kind,
+    id,
+    plan,
+    () => backend.updateNode({
+      graphId: ctx.graphId,
+      kind,
+      id,
+      props,
+      incrementVersion: true,
+      clearDeleted: true
+    })
+  );
+  await Promise.all([
+    syncEmbeddings(nodeSyncContext(ctx, kind, id, backend), args.schema, props),
+    syncFulltext(nodeSyncContext(ctx, kind, id, backend), args.schema, props)
+  ]);
+  return row;
+}
+
+export { AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, STORE_RUNTIME, TRANSACTION_RUNTIME, applyNodeHardDelete, applyNodeInsertSideEffects, applyNodeInsertSideEffectsBatch, applyNodeResurrect, applyNodeSoftDelete, applyNodeUpdate, checkUniquenessConstraints, computeFulltextContent, createNodeWriteContext, createUniquenessContext, getEmbeddingFields, storeBackend, storeRuntime, transactionBackend, transactionNodeOperationHookRunner };
+//# sourceMappingURL=chunk-M3WP7RQZ.js.map
+//# sourceMappingURL=chunk-M3WP7RQZ.js.map