@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/chunk-SIT26LAZ.cjs

@@ -0,0 +1,614 @@
+'use strict';
+
+var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
+
+// src/backend/graph-backend-keys.ts
+var GRAPH_BACKEND_PROJECTION_KEYS = [
+  "dialect",
+  "capabilities",
+  "tableNames",
+  "fulltextStrategy",
+  "vectorStrategy",
+  "insertNode",
+  "insertNodeNoReturn",
+  "insertNodesBatch",
+  "insertNodesBatchReturning",
+  "updateNode",
+  "updateNodeSet",
+  "deleteNode",
+  "hardDeleteNode",
+  "getNode",
+  "getNodes",
+  "insertEdge",
+  "insertEdgeNoReturn",
+  "insertEdgesBatch",
+  "insertEdgesBatchReturning",
+  "updateEdge",
+  "deleteEdge",
+  "hardDeleteEdge",
+  "deleteEdgesBatch",
+  "hardDeleteEdgesBatch",
+  "getEdge",
+  "getEdges",
+  "countEdgesFrom",
+  "edgeExistsBetween",
+  "findEdgesConnectedTo",
+  "findNodesByKind",
+  "countNodesByKind",
+  "findEdgesByKind",
+  "findEdgesByEndpointSet",
+  "findEdgesByHeterogeneousEndpointSet",
+  "countEdgesByKind",
+  "insertUnique",
+  "insertUniqueBatch",
+  "deleteUnique",
+  "hardDeleteUniquesByNodeIds",
+  "checkUnique",
+  "checkUniqueBatch",
+  "getActiveSchema",
+  "getSchemaVersion",
+  "commitSchemaVersion",
+  "commitSchemaVersionIfKindsEmpty",
+  "lockSchemaVersionForWrite",
+  "commitSchemaVersionWithPreflight",
+  "setActiveVersion",
+  "schemaWriteTransaction",
+  "upsertEmbedding",
+  "upsertEmbeddingBatch",
+  "deleteEmbedding",
+  "deleteEmbeddingBatch",
+  "vectorSearch",
+  "createVectorIndex",
+  "dropVectorIndex",
+  "hybridSearch",
+  "upsertFulltext",
+  "deleteFulltext",
+  "upsertFulltextBatch",
+  "deleteFulltextBatch",
+  "fulltextSearch",
+  "ensureIndexMaterializationsTable",
+  "ensureTrigramExtension",
+  "ensureRevisionOriginsTable",
+  "getIndexMaterialization",
+  "getIndexMaterializations",
+  "recordIndexMaterialization",
+  "claimIndexMaterialization",
+  "releaseIndexMaterializationClaim",
+  "ensureContributionMaterializationsTable",
+  "getContributionMaterialization",
+  "recordContributionMaterialization",
+  "assertRuntimeContributionsInitialized",
+  "ensureKindRemovalsTable",
+  "getPendingKindRemovals",
+  "getAllKindRemovals",
+  "recordKindRemoval",
+  "ensureReconciliationMarkersTable",
+  "ensureRuntimeContributions",
+  "ensureVectorSlotContribution",
+  "ensureVectorSlotContributions",
+  "assertVectorSlotInitialized",
+  "assertVectorSlotsInitialized",
+  "deleteVectorSlotContribution",
+  "verifyContributions",
+  "repairContributions",
+  "probeContributions",
+  "rebuildContribution",
+  "ensureFulltextTable",
+  "ensureIdentityTables",
+  "identityTableDdl",
+  "getReconciliationMarker",
+  "setReconciliationMarker",
+  "clearGraph",
+  "bootstrapTables",
+  "refreshStatistics",
+  "trustedImport",
+  "execute",
+  "executeStatement",
+  "executeTemporaryStatement",
+  "executeRaw",
+  "compileSql",
+  "executeDdl",
+  "transaction",
+  "close"
+];
+
+// src/backend/transaction-resource.ts
+var BACKEND_RESOURCE_AUDITS = /* @__PURE__ */ new WeakMap();
+var ACTIVE_SERIALIZED_STREAMS = /* @__PURE__ */ new Map();
+function auditsAgree(left, right) {
+  if (left.kind === "serialized") {
+    return right.kind === "serialized" && left.resource === right.resource;
+  }
+  return right.kind === "independent" && left.identityLeaseResource === right.identityLeaseResource;
+}
+function formatAudit(audit) {
+  return audit.kind === "serialized" ? "serialized" : "independent";
+}
+var SERIALIZED_RESOURCE_CONFLICTS = /* @__PURE__ */ new WeakMap();
+function describeSerializedResource(resource) {
+  const constructorName = resource.constructor?.name;
+  return typeof constructorName === "string" && constructorName !== "" ? constructorName : "Object";
+}
+function resolveDeclaredBackendResource(detected, declaration) {
+  switch (declaration?.mode) {
+    case "shared": {
+      if (detected !== void 0 && detected !== declaration.resource) {
+        const refusal = new chunkMRDBBHIZ_cjs.ConfigurationError(
+          `serializedResource declared { mode: "shared" } naming an object that is not the connection this backend was detected to run on. Two wrappers over one connection must name the SAME object, or the guards that refuse a concurrent export/import pair on it stop seeing them as one resource.`,
+          {
+            reason: "serialized-resource-conflict",
+            declaredKind: describeSerializedResource(declaration.resource),
+            detectedKind: describeSerializedResource(detected)
+          },
+          {
+            suggestion: `Declare the client TypeGraph already detected (or drop the declaration and let detection stand). Use { mode: "independent" } if the detection is wrong and this backend really does run on its own connection.`
+          }
+        );
+        SERIALIZED_RESOURCE_CONFLICTS.set(refusal, {
+          declared: declaration.resource,
+          detected
+        });
+        throw refusal;
+      }
+      return { kind: "serialized", resource: declaration.resource };
+    }
+    case "independent": {
+      return { kind: "independent", identityLeaseResource: {} };
+    }
+    case "detect":
+    case void 0: {
+      return detected === void 0 ? { kind: "independent" } : { kind: "serialized", resource: detected };
+    }
+  }
+}
+function auditBackendResource(backend, audit) {
+  const recorded = BACKEND_RESOURCE_AUDITS.get(backend);
+  if (recorded !== void 0) {
+    if (auditsAgree(recorded, audit)) return;
+    throw new TypeError(
+      `A backend's serialized-resource audit is written once: this backend was audited "${formatAudit(recorded)}" and a conflicting audit "${formatAudit(audit)}"${recorded.kind === "serialized" && audit.kind === "serialized" ? " naming a different connection" : ""} was attempted. The stream lease closes over the resource it claimed, so a verdict that changes under a live lease de-serializes a pair that really does share a connection.`
+    );
+  }
+  BACKEND_RESOURCE_AUDITS.set(backend, audit);
+}
+function carryBackendResourceAudit(derived, base) {
+  const audit = BACKEND_RESOURCE_AUDITS.get(base);
+  if (audit !== void 0) BACKEND_RESOURCE_AUDITS.set(derived, audit);
+}
+function resolveBackendAudit(backend) {
+  return BACKEND_RESOURCE_AUDITS.get(backend);
+}
+function sharesSerializedTransactionResource(left, right) {
+  const leftAudit = resolveBackendAudit(left);
+  if (leftAudit?.kind !== "serialized") return false;
+  const rightAudit = resolveBackendAudit(right);
+  return rightAudit?.kind === "serialized" && leftAudit.resource === rightAudit.resource;
+}
+function snapshotExportContention(source, target) {
+  if (!source.capabilities.transactions) return void 0;
+  if (source === target && source.dialect === "sqlite") {
+    return "same-sqlite-backend";
+  }
+  if (sharesSerializedTransactionResource(source, target)) {
+    return "shared-resource";
+  }
+  return void 0;
+}
+function streamLeaseResource(backend) {
+  const audit = resolveBackendAudit(backend);
+  if (audit?.kind === "serialized") return audit.resource;
+  if (audit?.kind === "independent" && audit.identityLeaseResource !== void 0 && backend.dialect === "sqlite" && backend.capabilities.transactions) {
+    return audit.identityLeaseResource;
+  }
+  return void 0;
+}
+function acquireSerializedStreamLease(backend, kind) {
+  const resource = streamLeaseResource(backend);
+  if (resource === void 0) {
+    return {
+      acquired: true,
+      resource: void 0,
+      release: () => {
+      }
+    };
+  }
+  const holder = ACTIVE_SERIALIZED_STREAMS.get(resource);
+  if (holder !== void 0) return { acquired: false, heldBy: holder };
+  ACTIVE_SERIALIZED_STREAMS.set(resource, kind);
+  let released = false;
+  return {
+    acquired: true,
+    resource,
+    release: () => {
+      if (released) return;
+      released = true;
+      ACTIVE_SERIALIZED_STREAMS.delete(resource);
+    }
+  };
+}
+
+// src/backend/derive-backend.ts
+function deriveBackend(base, overrides) {
+  function hasOverlayProperty(property) {
+    return Object.hasOwn(overrides, property);
+  }
+  const decoratedBackend = new Proxy(base, {
+    get(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.get(overrides, property, overrides);
+      }
+      return Reflect.get(targetObject, property, targetObject);
+    },
+    has(targetObject, property) {
+      return hasOverlayProperty(property) || Reflect.has(targetObject, property);
+    },
+    ownKeys(targetObject) {
+      return [
+        .../* @__PURE__ */ new Set([
+          ...Reflect.ownKeys(targetObject),
+          ...Reflect.ownKeys(overrides)
+        ])
+      ];
+    },
+    getOwnPropertyDescriptor(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(
+          overrides,
+          property
+        );
+        if (descriptor === void 0) return;
+        return { ...descriptor, configurable: true };
+      }
+      return Reflect.getOwnPropertyDescriptor(targetObject, property);
+    },
+    set(targetObject, property, value) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.set(overrides, property, value, overrides);
+      }
+      return Reflect.set(targetObject, property, value, targetObject);
+    },
+    defineProperty(targetObject, property, attributes) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.defineProperty(overrides, property, attributes);
+      }
+      return Reflect.defineProperty(targetObject, property, attributes);
+    },
+    deleteProperty(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.deleteProperty(overrides, property);
+      }
+      return Reflect.deleteProperty(targetObject, property);
+    }
+  });
+  carryBackendResourceAudit(decoratedBackend, base);
+  return decoratedBackend;
+}
+function projectBackend(base, keys) {
+  const entries = keys.flatMap((key) => {
+    if (!Reflect.has(base, key)) return [];
+    return [[key, Reflect.get(base, key)]];
+  });
+  const projection = Object.fromEntries(entries);
+  carryBackendResourceAudit(projection, base);
+  return projection;
+}
+function projectGraphBackend(base) {
+  return projectBackend(
+    base,
+    GRAPH_BACKEND_PROJECTION_KEYS
+  );
+}
+function wrapWithManagedClose(backend, teardown) {
+  let backendClosed = false;
+  let teardownComplete = false;
+  let closeInFlight;
+  async function closeManagedResources() {
+    const errors = [];
+    if (!backendClosed) {
+      try {
+        await backend.close();
+        backendClosed = true;
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (!teardownComplete) {
+      try {
+        await teardown();
+        teardownComplete = true;
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) {
+      throw new AggregateError(
+        errors,
+        "The backend and its managed resource both failed to close."
+      );
+    }
+  }
+  const closeOverlay = {
+    async close() {
+      if (backendClosed && teardownComplete) return;
+      closeInFlight ??= closeManagedResources().finally(() => {
+        closeInFlight = void 0;
+      });
+      await closeInFlight;
+    }
+  };
+  return deriveBackend(backend, closeOverlay);
+}
+
+// src/utils/sql-errors.ts
+var SQLITE_MISSING_TABLE_PATTERN = "no such table";
+var SQLITE_GENERIC_ERROR_CODE = "SQLITE_ERROR";
+var SQLITE_NOT_AUTHORIZED_CODE = "SQLITE_AUTH";
+var SQLITE_STALE_SNAPSHOT_CODE = "SQLITE_BUSY_SNAPSHOT";
+var SQLITE_STALE_SNAPSHOT_EXTENDED_CODE = 517;
+var DRIZZLE_QUERY_ERROR_PREFIX = "Failed query:";
+var POSTGRES_UNDEFINED_RELATION_PATTERN = /\b(?:relation|table)\s+"[^"]+"\s+does not exist\b/i;
+var POSTGRES_UNDEFINED_TABLE_CODE = "42P01";
+var POSTGRES_UNIQUE_VIOLATION_CODE = "23505";
+var POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES = [
+  POSTGRES_UNIQUE_VIOLATION_CODE,
+  "42701"
+];
+var POSTGRES_INTERNAL_ERROR_CODE = "XX000";
+var POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE = "tuple concurrently updated";
+var POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES = [
+  "25006",
+  "42501"
+];
+var POSTGRES_READ_WRITE_REFUSED_SQL_STATES = ["0A000", "25006"];
+function* errorChain(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== void 0 && current !== null && !seen.has(current)) {
+    seen.add(current);
+    yield current;
+    current = canReadProperty(current) ? Reflect.get(current, "cause") : void 0;
+  }
+}
+function canReadProperty(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPostgresUndefinedTable(link) {
+  return canReadProperty(link) && Reflect.get(link, "code") === POSTGRES_UNDEFINED_TABLE_CODE;
+}
+function messageProperty(link) {
+  if (typeof link === "string") return link;
+  if (link instanceof Error) return link.message;
+  const message = canReadProperty(link) ? Reflect.get(link, "message") : void 0;
+  return typeof message === "string" ? message : void 0;
+}
+function errorMessage(link) {
+  return messageProperty(link) ?? String(link);
+}
+function missingTableMessage(link) {
+  return typeof link === "string" || link instanceof Error ? messageProperty(link) : void 0;
+}
+function sqliteErrorCode(link) {
+  if (!canReadProperty(link)) return void 0;
+  return Reflect.get(link, "code");
+}
+function isBareSqliteErrorMarker(link) {
+  const message = messageProperty(link);
+  if (message === SQLITE_GENERIC_ERROR_CODE) return true;
+  if (sqliteErrorCode(link) !== SQLITE_GENERIC_ERROR_CODE) return false;
+  return message === void 0 || message === SQLITE_GENERIC_ERROR_CODE || message.includes(SQLITE_MISSING_TABLE_PATTERN);
+}
+function isPostgresUndefinedRelationMessage(link) {
+  const message = errorMessage(link);
+  if (message.startsWith(DRIZZLE_QUERY_ERROR_PREFIX)) return false;
+  return POSTGRES_UNDEFINED_RELATION_PATTERN.test(message);
+}
+function isInsufficientResourcesError(error) {
+  for (const link of errorChain(error)) {
+    if (!canReadProperty(link)) continue;
+    const code = Reflect.get(link, "code");
+    if (typeof code === "string" && code.length === 5 && code.startsWith("53"))
+      return true;
+  }
+  return false;
+}
+function isMissingTableError(error) {
+  let everyPriorLinkWasError = true;
+  for (const link of errorChain(error)) {
+    if (isPostgresUndefinedTable(link)) return true;
+    if (isPostgresUndefinedRelationMessage(link)) return true;
+    if (isBareSqliteErrorMarker(link)) return true;
+    if (everyPriorLinkWasError) {
+      const message = missingTableMessage(link);
+      if (message?.includes(SQLITE_MISSING_TABLE_PATTERN) === true) {
+        return true;
+      }
+    }
+    if (!(link instanceof Error)) everyPriorLinkWasError = false;
+  }
+  return false;
+}
+function isPostgresConcurrentTupleUpdate(link) {
+  if (!canReadProperty(link)) return false;
+  if (Reflect.get(link, "code") !== POSTGRES_INTERNAL_ERROR_CODE) return false;
+  return messageProperty(link)?.includes(
+    POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE
+  ) === true;
+}
+function isPostgresConcurrentDdlRaceError(error) {
+  for (const link of errorChain(error)) {
+    if (!canReadProperty(link)) continue;
+    if (isSqlStateIn(
+      Reflect.get(link, "code"),
+      POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES
+    )) {
+      return true;
+    }
+    if (isPostgresConcurrentTupleUpdate(link)) return true;
+  }
+  return false;
+}
+var POSTGRES_CONSTRAINT_FIELDS = ["constraint", "constraint_name"];
+var POSTGRES_RELATION_FIELDS = ["table", "table_name"];
+var SQLITE_PRIMARY_KEY_VIOLATION_CODE = "SQLITE_CONSTRAINT_PRIMARYKEY";
+var SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE = 1555;
+var SQLITE_EXTENDED_CODE_FIELDS = ["rawCode", "extendedCode"];
+function firstStringField(link, fields) {
+  for (const field of fields) {
+    const value = Reflect.get(link, field);
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function isPostgresPrimaryKeyViolation(link, relation) {
+  if (Reflect.get(link, "code") !== POSTGRES_UNIQUE_VIOLATION_CODE)
+    return false;
+  if (firstStringField(link, POSTGRES_RELATION_FIELDS) !== relation.table) {
+    return false;
+  }
+  const constraint = firstStringField(link, POSTGRES_CONSTRAINT_FIELDS);
+  return constraint !== void 0 && relation.constraintNames.includes(constraint);
+}
+function isSqlitePrimaryKeyViolation(link) {
+  if (Reflect.get(link, "code") === SQLITE_PRIMARY_KEY_VIOLATION_CODE) {
+    return true;
+  }
+  for (const field of SQLITE_EXTENDED_CODE_FIELDS) {
+    const value = Reflect.get(link, field);
+    if (typeof value === "number" && value === SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE) {
+      return true;
+    }
+  }
+  return false;
+}
+function isDuplicatePrimaryKeyError(error, relation) {
+  for (const link of errorChain(error)) {
+    if (!canReadProperty(link)) continue;
+    if (isPostgresPrimaryKeyViolation(link, relation)) return true;
+    if (isSqlitePrimaryKeyViolation(link)) return true;
+  }
+  return false;
+}
+function isSqlStateIn(code, states) {
+  const known = states;
+  return typeof code === "string" && known.includes(code);
+}
+function matchSqlState(error, states) {
+  for (const link of errorChain(error)) {
+    if (!canReadProperty(link)) continue;
+    const code = Reflect.get(link, "code");
+    if (isSqlStateIn(code, states)) return code;
+  }
+  return void 0;
+}
+function postgresTemporaryTableUnavailableSqlState(error) {
+  return matchSqlState(error, POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES);
+}
+function postgresReadWriteRefusedSqlState(error) {
+  return matchSqlState(error, POSTGRES_READ_WRITE_REFUSED_SQL_STATES);
+}
+function isSqliteNotAuthorizedError(error) {
+  for (const link of errorChain(error)) {
+    if (sqliteErrorCode(link) === SQLITE_NOT_AUTHORIZED_CODE) return true;
+    const message = messageProperty(link);
+    if (message?.includes(SQLITE_NOT_AUTHORIZED_CODE) === true && message.toLowerCase().includes("not authorized")) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSqliteStaleSnapshotError(error) {
+  for (const link of errorChain(error)) {
+    if (sqliteErrorCode(link) === SQLITE_STALE_SNAPSHOT_CODE) return true;
+    if (!canReadProperty(link)) continue;
+    for (const field of SQLITE_EXTENDED_CODE_FIELDS) {
+      if (Reflect.get(link, field) === SQLITE_STALE_SNAPSHOT_EXTENDED_CODE) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function historyMissingRecordedRelationsError(details, cause) {
+  return new chunkMRDBBHIZ_cjs.ConfigurationError(
+    "history: true requires the recorded-time relations to exist, but a recorded relation is missing.",
+    details,
+    {
+      cause,
+      suggestion: "Create the recorded-time relations (typegraph_recorded_nodes, typegraph_recorded_edges, typegraph_recorded_clock) \u2014 e.g. re-run the generated migration SQL \u2014 on this database before enabling history capture."
+    }
+  );
+}
+async function withRecordedRelationsPrecondition(promise, details) {
+  try {
+    return await promise;
+  } catch (error) {
+    if (!isMissingTableError(error)) throw error;
+    throw historyMissingRecordedRelationsError(
+      { ...details, code: "RECORDED_RELATIONS_MISSING" },
+      error
+    );
+  }
+}
+var DIMENSION_MISMATCH_PATTERN = /expected (\d+) dimensions(?:[,\s]+(?:not|got|but got|but)\s*(\d+))?/i;
+function parseDimensionMismatch(error) {
+  for (const link of errorChain(error)) {
+    const message = errorMessage(link);
+    const match = DIMENSION_MISMATCH_PATTERN.exec(message);
+    if (match) {
+      return {
+        expected: Number(match[1]),
+        actual: match[2] === void 0 ? void 0 : Number(match[2])
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/utils/array.ts
+function chunk(items, size) {
+  if (!Number.isSafeInteger(size) || size < 1) {
+    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);
+  }
+  if (items.length === 0) return [];
+  if (items.length <= size) return [items];
+  const chunks = [];
+  for (let start = 0; start < items.length; start += size) {
+    chunks.push(items.slice(start, start + size));
+  }
+  return chunks;
+}
+function groupBy(items, keyFor) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFor(item);
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
+exports.acquireSerializedStreamLease = acquireSerializedStreamLease;
+exports.auditBackendResource = auditBackendResource;
+exports.chunk = chunk;
+exports.deriveBackend = deriveBackend;
+exports.errorChain = errorChain;
+exports.groupBy = groupBy;
+exports.isDuplicatePrimaryKeyError = isDuplicatePrimaryKeyError;
+exports.isInsufficientResourcesError = isInsufficientResourcesError;
+exports.isMissingTableError = isMissingTableError;
+exports.isPostgresConcurrentDdlRaceError = isPostgresConcurrentDdlRaceError;
+exports.isSqliteNotAuthorizedError = isSqliteNotAuthorizedError;
+exports.isSqliteStaleSnapshotError = isSqliteStaleSnapshotError;
+exports.parseDimensionMismatch = parseDimensionMismatch;
+exports.postgresReadWriteRefusedSqlState = postgresReadWriteRefusedSqlState;
+exports.postgresTemporaryTableUnavailableSqlState = postgresTemporaryTableUnavailableSqlState;
+exports.projectBackend = projectBackend;
+exports.projectGraphBackend = projectGraphBackend;
+exports.resolveDeclaredBackendResource = resolveDeclaredBackendResource;
+exports.snapshotExportContention = snapshotExportContention;
+exports.withRecordedRelationsPrecondition = withRecordedRelationsPrecondition;
+exports.wrapWithManagedClose = wrapWithManagedClose;
+//# sourceMappingURL=chunk-SIT26LAZ.cjs.map
+//# sourceMappingURL=chunk-SIT26LAZ.cjs.map