@nicia-ai/typegraph 0.5.0 → 0.6.0

package/dist/chunk-PW5BSBZV.cjs

@@ -1,1527 +0,0 @@
-'use strict';
-
-var chunk44SXEVF4_cjs = require('./chunk-44SXEVF4.cjs');
-var drizzleOrm = require('drizzle-orm');
-
-// src/backend/types.ts
-var SQLITE_CAPABILITIES = {
-  jsonb: false,
-  // SQLite uses TEXT with json functions
-  partialIndexes: true,
-  // SQLite supports WHERE in CREATE INDEX
-  ginIndexes: false,
-  // SQLite doesn't have GIN
-  cte: true,
-  // SQLite supports WITH
-  returning: true,
-  // SQLite 3.35+ supports RETURNING
-  transactions: true
-  // SQLite supports transactions
-};
-var POSTGRES_CAPABILITIES = {
-  jsonb: true,
-  // PostgreSQL has native JSONB
-  partialIndexes: true,
-  ginIndexes: true,
-  cte: true,
-  returning: true,
-  transactions: true
-  // PostgreSQL supports transactions
-};
-var D1_CAPABILITIES = {
-  jsonb: false,
-  // D1 uses TEXT with json functions
-  partialIndexes: true,
-  ginIndexes: false,
-  cte: true,
-  returning: true,
-  transactions: false
-  // D1 does NOT support atomic transactions
-};
-
-// src/backend/drizzle/row-mappers.ts
-function requireTimestamp(value, field) {
-  if (value === void 0) {
-    throw new chunk44SXEVF4_cjs.DatabaseOperationError(
-      `Expected non-null ${field} timestamp`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function nullToUndefined(value) {
-  return value ?? void 0;
-}
-function formatPostgresTimestamp(value) {
-  if (value === null || value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") {
-    if (value.includes("T")) return value;
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) return date.toISOString();
-    return value;
-  }
-  return void 0;
-}
-function normalizeJsonColumn(value) {
-  return typeof value === "string" ? value : JSON.stringify(value ?? {});
-}
-var SQLITE_ROW_MAPPER_CONFIG = {
-  formatTimestamp: (value) => nullToUndefined(value),
-  normalizeJson: (value) => value
-};
-var POSTGRES_ROW_MAPPER_CONFIG = {
-  formatTimestamp: formatPostgresTimestamp,
-  normalizeJson: normalizeJsonColumn
-};
-function createNodeRowMapper(config) {
-  return (row) => ({
-    graph_id: row.graph_id,
-    kind: row.kind,
-    id: row.id,
-    props: config.normalizeJson(row.props),
-    version: row.version,
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createEdgeRowMapper(config) {
-  return (row) => ({
-    graph_id: row.graph_id,
-    id: row.id,
-    kind: row.kind,
-    from_kind: row.from_kind,
-    from_id: row.from_id,
-    to_kind: row.to_kind,
-    to_id: row.to_id,
-    props: config.normalizeJson(row.props),
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createUniqueRowMapper(config) {
-  return (row) => ({
-    graph_id: row.graph_id,
-    node_kind: row.node_kind,
-    constraint_name: row.constraint_name,
-    key: row.key,
-    node_id: row.node_id,
-    concrete_kind: row.concrete_kind,
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createSchemaVersionRowMapper(config) {
-  return (row) => {
-    const isActiveValue = row.is_active;
-    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
-    return {
-      graph_id: row.graph_id,
-      version: row.version,
-      schema_hash: row.schema_hash,
-      schema_doc: config.normalizeJson(row.schema_doc),
-      created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-      is_active: isActive
-    };
-  };
-}
-
-// src/backend/drizzle/operation-backend-core.ts
-function chunkArray(values, size) {
-  if (values.length <= size) {
-    return [values];
-  }
-  const chunks = [];
-  for (let index = 0; index < values.length; index += size) {
-    chunks.push(values.slice(index, index + size));
-  }
-  return chunks;
-}
-function createCommonOperationBackend(options) {
-  const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? nowIso;
-  return {
-    async insertNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertNode(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunk44SXEVF4_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
-      return rowMappers.toNodeRow(row);
-    },
-    async insertNodeNoReturn(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertNodeNoReturn(params, timestamp);
-      await execution.execRun(query);
-    },
-    async insertNodesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp = nowIso2();
-      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk, timestamp);
-        await execution.execRun(query);
-      }
-    },
-    async insertNodesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp = nowIso2();
-      const allRows = [];
-      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatchReturning(chunk, timestamp);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
-    },
-    async getNode(graphId, kind, id) {
-      const query = operationStrategy.buildGetNode(graphId, kind, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toNodeRow(row) : void 0;
-    },
-    async getNodes(graphId, kind, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk of chunkArray(ids, batchConfig.getNodesChunkSize)) {
-        const query = operationStrategy.buildGetNodes(graphId, kind, chunk);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
-    },
-    async updateNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunk44SXEVF4_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
-      return rowMappers.toNodeRow(row);
-    },
-    async deleteNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp);
-      await execution.execRun(query);
-    },
-    // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
-    // within a transaction to prevent partial deletion on intermediate failure.
-    async hardDeleteNode(params) {
-      const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
-        params.graphId,
-        params.id
-      );
-      await execution.execRun(deleteUniquesQuery);
-      const deleteEmbeddingsQuery = operationStrategy.buildHardDeleteEmbeddingsByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteEmbeddingsQuery);
-      const deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteEdgesQuery);
-      const query = operationStrategy.buildHardDeleteNode(params);
-      await execution.execRun(query);
-    },
-    async insertEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunk44SXEVF4_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
-      return rowMappers.toEdgeRow(row);
-    },
-    async insertEdgeNoReturn(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp);
-      await execution.execRun(query);
-    },
-    async insertEdgesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp = nowIso2();
-      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk, timestamp);
-        await execution.execRun(query);
-      }
-    },
-    async insertEdgesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp = nowIso2();
-      const allRows = [];
-      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk, timestamp);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
-    },
-    async getEdge(graphId, id) {
-      const query = operationStrategy.buildGetEdge(graphId, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toEdgeRow(row) : void 0;
-    },
-    async getEdges(graphId, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk of chunkArray(ids, batchConfig.getEdgesChunkSize)) {
-        const query = operationStrategy.buildGetEdges(graphId, chunk);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
-    },
-    async updateEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateEdge(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunk44SXEVF4_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
-      return rowMappers.toEdgeRow(row);
-    },
-    async deleteEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteEdge(params, timestamp);
-      await execution.execRun(query);
-    },
-    async hardDeleteEdge(params) {
-      const query = operationStrategy.buildHardDeleteEdge(params);
-      await execution.execRun(query);
-    },
-    async countEdgesFrom(params) {
-      const query = operationStrategy.buildCountEdgesFrom(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async edgeExistsBetween(params) {
-      const query = operationStrategy.buildEdgeExistsBetween(params);
-      const row = await execution.execGet(query);
-      return row !== void 0;
-    },
-    async findEdgesConnectedTo(params) {
-      const query = operationStrategy.buildFindEdgesConnectedTo(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async findNodesByKind(params) {
-      const query = operationStrategy.buildFindNodesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toNodeRow(row));
-    },
-    async countNodesByKind(params) {
-      const query = operationStrategy.buildCountNodesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async findEdgesByKind(params) {
-      const query = operationStrategy.buildFindEdgesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async countEdgesByKind(params) {
-      const query = operationStrategy.buildCountEdgesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async insertUnique(params) {
-      const query = operationStrategy.buildInsertUnique(params);
-      const result = await execution.execGet(query);
-      if (result && result.node_id !== params.nodeId) {
-        throw new chunk44SXEVF4_cjs.UniquenessError({
-          constraintName: params.constraintName,
-          kind: params.nodeKind,
-          existingId: result.node_id,
-          newId: params.nodeId,
-          fields: []
-        });
-      }
-    },
-    async deleteUnique(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteUnique(params, timestamp);
-      await execution.execRun(query);
-    },
-    async checkUnique(params) {
-      const query = operationStrategy.buildCheckUnique(params);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toUniqueRow(row) : void 0;
-    },
-    async checkUniqueBatch(params) {
-      if (params.keys.length === 0) return [];
-      const query = operationStrategy.buildCheckUniqueBatch(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toUniqueRow(row));
-    },
-    async getActiveSchema(graphId) {
-      const query = operationStrategy.buildGetActiveSchema(graphId);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async insertSchema(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertSchema(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunk44SXEVF4_cjs.DatabaseOperationError("Insert schema failed: no row returned", { operation: "insert", entity: "schema" });
-      return rowMappers.toSchemaVersionRow(row);
-    },
-    async getSchemaVersion(graphId, version) {
-      const query = operationStrategy.buildGetSchemaVersion(graphId, version);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async setActiveSchema(graphId, version) {
-      const queries = operationStrategy.buildSetActiveSchema(graphId, version);
-      await execution.execRun(queries.deactivateAll);
-      await execution.execRun(queries.activateVersion);
-    },
-    async clearGraph(graphId) {
-      const statements = operationStrategy.buildClearGraph(graphId);
-      for (const statement of statements) {
-        await execution.execRun(statement);
-      }
-    }
-  };
-}
-function buildClearGraph(tables, graphId) {
-  return [
-    drizzleOrm.sql`DELETE FROM ${tables.embeddings} WHERE ${tables.embeddings.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
-  ];
-}
-function buildTemporalConditions(table, params) {
-  const conditions = [];
-  const mode = params.temporalMode;
-  if (mode === "includeTombstones") return conditions;
-  if (params.excludeDeleted !== false) {
-    conditions.push(drizzleOrm.sql`${table.deletedAt} IS NULL`);
-  }
-  if (mode === "current" || mode === "asOf") {
-    const asOf = params.asOf;
-    conditions.push(
-      drizzleOrm.sql`(${table.validFrom} IS NULL OR ${table.validFrom} <= ${asOf})`,
-      drizzleOrm.sql`(${table.validTo} IS NULL OR ${table.validTo} > ${asOf})`
-    );
-  }
-  return conditions;
-}
-function buildFindNodesByKind(tables, params) {
-  const { nodes } = tables;
-  const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
-  ];
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  if (params.limit !== void 0 && params.offset !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
-      WHERE ${whereClause}
-      ORDER BY ${nodes.createdAt} DESC
-      LIMIT ${params.limit} OFFSET ${params.offset}
-    `;
-  }
-  if (params.limit !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
-      WHERE ${whereClause}
-      ORDER BY ${nodes.createdAt} DESC
-      LIMIT ${params.limit}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${whereClause}
-    ORDER BY ${nodes.createdAt} DESC
-  `;
-}
-function buildCountNodesByKind(tables, params) {
-  const { nodes } = tables;
-  const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
-  ];
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${nodes}
-    WHERE ${whereClause}
-  `;
-}
-function buildFindEdgesByKind(tables, params) {
-  const { edges } = tables;
-  const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
-  ];
-  if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
-  }
-  if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
-  }
-  if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
-  }
-  if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  if (params.limit !== void 0 && params.offset !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${edges}
-      WHERE ${whereClause}
-      ORDER BY ${edges.createdAt} DESC
-      LIMIT ${params.limit} OFFSET ${params.offset}
-    `;
-  }
-  if (params.limit !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${edges}
-      WHERE ${whereClause}
-      ORDER BY ${edges.createdAt} DESC
-      LIMIT ${params.limit}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${whereClause}
-    ORDER BY ${edges.createdAt} DESC
-  `;
-}
-function buildCountEdgesByKind(tables, params) {
-  const { edges } = tables;
-  const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
-  ];
-  if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
-  }
-  if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
-  }
-  if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
-  }
-  if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
-    WHERE ${whereClause}
-  `;
-}
-function sqlNull(value) {
-  return value ?? drizzleOrm.sql.raw("NULL");
-}
-function quotedColumn(column) {
-  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function nodeColumnList(nodes) {
-  return drizzleOrm.sql.raw(`"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`);
-}
-function edgeColumnList(edges) {
-  return drizzleOrm.sql.raw(`"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`);
-}
-
-// src/backend/drizzle/operations/edges.ts
-function buildInsertEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.id}, ${params.kind},
-      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-    RETURNING *
-  `;
-}
-function buildInsertEdgeNoReturn(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.id}, ${params.kind},
-      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-  `;
-}
-function buildInsertEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = edgeColumnList(edges);
-  const values = params.map((edgeParams) => {
-    const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-  `;
-}
-function buildInsertEdgesBatchReturning(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = edgeColumnList(edges);
-  const values = params.map((edgeParams) => {
-    const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-    RETURNING *
-  `;
-}
-function buildGetEdge(tables, graphId, id) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} = ${id}
-  `;
-}
-function buildGetEdges(tables, graphId, ids) {
-  const { edges } = tables;
-  const idPlaceholders = drizzleOrm.sql.join(
-    ids.map((edgeId) => drizzleOrm.sql`${edgeId}`),
-    drizzleOrm.sql`, `
-  );
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} IN (${idPlaceholders})
-  `;
-}
-function buildUpdateEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const setParts = [
-    drizzleOrm.sql`${quotedColumn(edges.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
-  ];
-  if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
-  }
-  if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.deletedAt)} = NULL`);
-  }
-  const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  if (params.clearDeleted) {
-    return drizzleOrm.sql`
-      UPDATE ${edges}
-      SET ${setClause}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}
-      RETURNING *
-    `;
-  }
-  return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${setClause}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
-      AND ${edges.deletedAt} IS NULL
-    RETURNING *
-  `;
-}
-function buildDeleteEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
-      AND ${edges.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteEdge(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
-  `;
-}
-function buildHardDeleteEdgesByNode(tables, graphId, nodeKind, nodeId) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND (
-        (${edges.fromKind} = ${nodeKind} AND ${edges.fromId} = ${nodeId})
-        OR (${edges.toKind} = ${nodeKind} AND ${edges.toId} = ${nodeId})
-      )
-  `;
-}
-function buildCountEdgesFrom(tables, params) {
-  const { edges } = tables;
-  if (params.activeOnly) {
-    return drizzleOrm.sql`
-      SELECT COUNT(*) as count FROM ${edges}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.kind} = ${params.edgeKind}
-        AND ${edges.fromKind} = ${params.fromKind}
-        AND ${edges.fromId} = ${params.fromId}
-        AND ${edges.deletedAt} IS NULL
-        AND ${edges.validTo} IS NULL
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.deletedAt} IS NULL
-  `;
-}
-function buildEdgeExistsBetween(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT 1 FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.toKind} = ${params.toKind}
-      AND ${edges.toId} = ${params.toId}
-      AND ${edges.deletedAt} IS NULL
-    LIMIT 1
-  `;
-}
-function buildFindEdgesConnectedTo(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.fromKind} = ${params.nodeKind}
-      AND ${edges.fromId} = ${params.nodeId}
-    UNION ALL
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.toKind} = ${params.nodeKind}
-      AND ${edges.toId} = ${params.nodeId}
-      AND NOT (
-        ${edges.fromKind} = ${params.nodeKind}
-        AND ${edges.fromId} = ${params.nodeId}
-      )
-  `;
-}
-function buildInsertNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-    RETURNING *
-  `;
-}
-function buildInsertNodeNoReturn(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-  `;
-}
-function buildInsertNodesBatch(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
-  const values = params.map((nodeParams) => {
-    const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-  `;
-}
-function buildInsertNodesBatchReturning(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
-  const values = params.map((nodeParams) => {
-    const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-    RETURNING *
-  `;
-}
-function buildGetNode(tables, graphId, kind, id) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} = ${id}
-  `;
-}
-function buildGetNodes(tables, graphId, kind, ids) {
-  const { nodes } = tables;
-  const idPlaceholders = drizzleOrm.sql.join(
-    ids.map((nodeId) => drizzleOrm.sql`${nodeId}`),
-    drizzleOrm.sql`, `
-  );
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} IN (${idPlaceholders})
-  `;
-}
-function buildUpdateNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const setParts = [
-    drizzleOrm.sql`${quotedColumn(nodes.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
-  ];
-  if (params.incrementVersion) {
-    setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
-    );
-  }
-  if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
-  }
-  if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.deletedAt)} = NULL`);
-  }
-  const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  if (params.clearDeleted) {
-    return drizzleOrm.sql`
-      UPDATE ${nodes}
-      SET ${setClause}
-      WHERE ${nodes.graphId} = ${params.graphId}
-        AND ${nodes.kind} = ${params.kind}
-        AND ${nodes.id} = ${params.id}
-      RETURNING *
-    `;
-  }
-  return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${setClause}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-      AND ${nodes.deletedAt} IS NULL
-    RETURNING *
-  `;
-}
-function buildDeleteNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${quotedColumn(nodes.deletedAt)} = ${timestamp}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-      AND ${nodes.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteNode(tables, params) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${nodes}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-  `;
-}
-function createSchemaDialectStrategy(dialect) {
-  const trueLiteral = dialect === "sqlite" ? drizzleOrm.sql.raw("1") : drizzleOrm.sql.raw("TRUE");
-  const falseLiteral = dialect === "sqlite" ? drizzleOrm.sql.raw("0") : drizzleOrm.sql.raw("FALSE");
-  return {
-    booleanLiteral(value) {
-      return value ? trueLiteral : falseLiteral;
-    }
-  };
-}
-var SCHEMA_DIALECT_STRATEGIES = {
-  postgres: createSchemaDialectStrategy("postgres"),
-  sqlite: createSchemaDialectStrategy("sqlite")
-};
-function buildInsertSchema(tables, params, timestamp, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  const schemaDocumentJson = JSON.stringify(params.schemaDoc);
-  const isActiveValue = strategy.booleanLiteral(params.isActive);
-  const columns = drizzleOrm.sql.raw(`"${schemaVersions.graphId.name}", "${schemaVersions.version.name}", "${schemaVersions.schemaHash.name}", "${schemaVersions.schemaDoc.name}", "${schemaVersions.createdAt.name}", "${schemaVersions.isActive.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${schemaVersions} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.version},
-      ${params.schemaHash}, ${schemaDocumentJson},
-      ${timestamp}, ${isActiveValue}
-    )
-    RETURNING *
-  `;
-}
-function buildGetActiveSchema(tables, graphId, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.isActive} = ${strategy.booleanLiteral(true)}
-  `;
-}
-function buildGetSchemaVersion(tables, graphId, version) {
-  const { schemaVersions } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
-  `;
-}
-function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  const deactivateAll = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-  `;
-  const activateVersion = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
-  `;
-  return { deactivateAll, activateVersion };
-}
-function buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`);
-  const conflictColumns = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-function buildInsertUniquePostgres(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`);
-  const conflictColumns = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`);
-  const tableName = drizzleOrm.getTableName(uniques);
-  const existingColumn = (column) => drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-var UNIQUE_INSERT_BUILDERS = {
-  postgres: buildInsertUniquePostgres,
-  sqlite: buildInsertUniqueSqlite
-};
-function buildInsertUnique(tables, dialect, params) {
-  const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables, params);
-}
-function buildDeleteUnique(tables, params, timestamp) {
-  const { uniques } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${uniques}
-    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteUniquesByNode(tables, graphId, nodeId) {
-  const { uniques } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${uniques}
-    WHERE ${uniques.graphId} = ${graphId}
-      AND ${uniques.nodeId} = ${nodeId}
-  `;
-}
-function buildHardDeleteEmbeddingsByNode(tables, graphId, nodeKind, nodeId) {
-  const { embeddings } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${embeddings}
-    WHERE ${embeddings.graphId} = ${graphId}
-      AND ${embeddings.nodeKind} = ${nodeKind}
-      AND ${embeddings.nodeId} = ${nodeId}
-  `;
-}
-function buildCheckUnique(tables, params) {
-  const { uniques } = tables;
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} = ${params.key}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildCheckUniqueBatch(tables, params) {
-  const { uniques } = tables;
-  const keyPlaceholders = drizzleOrm.sql.join(
-    params.keys.map((key) => drizzleOrm.sql`${key}`),
-    drizzleOrm.sql`, `
-  );
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} IN (${keyPlaceholders})
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} IN (${keyPlaceholders})
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function assertFiniteNumberArray(array, name) {
-  for (const [index, value] of array.entries()) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new TypeError(
-        `${name}[${index}] must be a finite number, got: ${value}`
-      );
-    }
-  }
-}
-function formatEmbeddingLiteral(embedding) {
-  assertFiniteNumberArray(embedding, "embedding");
-  return `[${embedding.join(",")}]`;
-}
-function buildUpsertEmbeddingPostgres(tables, params, timestamp) {
-  const { embeddings } = tables;
-  const embeddingLiteral = formatEmbeddingLiteral(params.embedding);
-  const columns = drizzleOrm.sql.raw(
-    `"${embeddings.graphId.name}", "${embeddings.nodeKind.name}", "${embeddings.nodeId.name}", "${embeddings.fieldPath.name}", "${embeddings.embedding.name}", "${embeddings.dimensions.name}", "${embeddings.createdAt.name}", "${embeddings.updatedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${embeddings.graphId.name}", "${embeddings.nodeKind.name}", "${embeddings.nodeId.name}", "${embeddings.fieldPath.name}"`
-  );
-  const column = (target) => drizzleOrm.sql.raw(`"${target.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${embeddings} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.fieldPath},
-      ${embeddingLiteral}::vector, ${params.dimensions}, ${timestamp}, ${timestamp}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${column(embeddings.embedding)} = ${embeddingLiteral}::vector,
-      ${column(embeddings.dimensions)} = ${params.dimensions},
-      ${column(embeddings.updatedAt)} = ${timestamp}
-  `;
-}
-function buildDeleteEmbedding(tables, params) {
-  const { embeddings } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${embeddings}
-    WHERE ${embeddings.graphId} = ${params.graphId}
-      AND ${embeddings.nodeKind} = ${params.nodeKind}
-      AND ${embeddings.nodeId} = ${params.nodeId}
-      AND ${embeddings.fieldPath} = ${params.fieldPath}
-  `;
-}
-function buildGetEmbedding(tables, graphId, nodeKind, nodeId, fieldPath) {
-  const { embeddings } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${embeddings}
-    WHERE ${embeddings.graphId} = ${graphId}
-      AND ${embeddings.nodeKind} = ${nodeKind}
-      AND ${embeddings.nodeId} = ${nodeId}
-      AND ${embeddings.fieldPath} = ${fieldPath}
-  `;
-}
-function buildDistanceExpression(embeddingColumn, queryLiteral, metric) {
-  const vectorParameter = drizzleOrm.sql`${queryLiteral}::vector`;
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`(${embeddingColumn} <=> ${vectorParameter})`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`(${embeddingColumn} <-> ${vectorParameter})`;
-    }
-    case "inner_product": {
-      return drizzleOrm.sql`(${embeddingColumn} <#> ${vectorParameter})`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchScoreExpression(distanceExpression, metric) {
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`(1 - (${distanceExpression}))`;
-    }
-    case "l2":
-    case "inner_product": {
-      return distanceExpression;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchMinScoreCondition(distanceExpression, metric, minScore) {
-  switch (metric) {
-    case "cosine": {
-      const threshold = 1 - minScore;
-      return drizzleOrm.sql`${distanceExpression} <= ${threshold}`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      const negativeThreshold = -minScore;
-      return drizzleOrm.sql`${distanceExpression} <= ${negativeThreshold}`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function buildVectorSearchPostgres(tables, params) {
-  const { embeddings } = tables;
-  const queryLiteral = formatEmbeddingLiteral(params.queryEmbedding);
-  if (params.minScore !== void 0 && !Number.isFinite(params.minScore)) {
-    throw new TypeError(
-      `minScore must be a finite number, got: ${params.minScore}`
-    );
-  }
-  if (!Number.isInteger(params.limit) || params.limit <= 0) {
-    throw new Error(`limit must be a positive integer, got: ${params.limit}`);
-  }
-  const embeddingColumn = drizzleOrm.sql`${embeddings.embedding}`;
-  const distanceExpression = buildDistanceExpression(
-    embeddingColumn,
-    queryLiteral,
-    params.metric
-  );
-  const conditions = [
-    drizzleOrm.sql`${embeddings.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${embeddings.nodeKind} = ${params.nodeKind}`,
-    drizzleOrm.sql`${embeddings.fieldPath} = ${params.fieldPath}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(
-      buildVectorSearchMinScoreCondition(
-        distanceExpression,
-        params.metric,
-        params.minScore
-      )
-    );
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const scoreExpression = buildVectorSearchScoreExpression(
-    distanceExpression,
-    params.metric
-  );
-  return drizzleOrm.sql`
-    SELECT
-      ${embeddings.nodeId} as node_id,
-      ${scoreExpression} as score
-    FROM ${embeddings}
-    WHERE ${whereClause}
-    ORDER BY ${distanceExpression} ASC
-    LIMIT ${params.limit}
-  `;
-}
-
-// src/backend/drizzle/operations/strategy.ts
-function bindTableOperationBuilders(tables, builders) {
-  const boundEntries = Object.entries(builders).map(([name, builder]) => {
-    function boundBuilder(...args) {
-      return builder(tables, ...args);
-    }
-    return [name, boundBuilder];
-  });
-  return Object.fromEntries(boundEntries);
-}
-var COMMON_TABLE_OPERATION_BUILDERS = {
-  buildInsertNode,
-  buildInsertNodeNoReturn,
-  buildInsertNodesBatch,
-  buildInsertNodesBatchReturning,
-  buildGetNode,
-  buildGetNodes,
-  buildUpdateNode,
-  buildDeleteNode,
-  buildHardDeleteNode,
-  buildInsertEdge,
-  buildInsertEdgeNoReturn,
-  buildInsertEdgesBatch,
-  buildInsertEdgesBatchReturning,
-  buildGetEdge,
-  buildGetEdges,
-  buildUpdateEdge,
-  buildDeleteEdge,
-  buildHardDeleteEdge,
-  buildHardDeleteEdgesByNode,
-  buildCountEdgesFrom,
-  buildEdgeExistsBetween,
-  buildFindEdgesConnectedTo,
-  buildFindNodesByKind,
-  buildCountNodesByKind,
-  buildFindEdgesByKind,
-  buildCountEdgesByKind,
-  buildDeleteUnique,
-  buildHardDeleteUniquesByNode,
-  buildHardDeleteEmbeddingsByNode,
-  buildCheckUnique,
-  buildCheckUniqueBatch,
-  buildGetSchemaVersion
-};
-function createCommonOperationStrategy(tables, dialect) {
-  const tableOperations = bindTableOperationBuilders(
-    tables,
-    COMMON_TABLE_OPERATION_BUILDERS
-  );
-  return {
-    ...tableOperations,
-    buildInsertUnique(params) {
-      return buildInsertUnique(tables, dialect, params);
-    },
-    buildGetActiveSchema(graphId) {
-      return buildGetActiveSchema(tables, graphId, dialect);
-    },
-    buildInsertSchema(params, timestamp) {
-      return buildInsertSchema(tables, params, timestamp, dialect);
-    },
-    buildSetActiveSchema(graphId, version) {
-      return buildSetActiveSchema(tables, graphId, version, dialect);
-    },
-    buildClearGraph(graphId) {
-      return buildClearGraph(tables, graphId);
-    }
-  };
-}
-function createSqliteOperationStrategy(tables) {
-  return createCommonOperationStrategy(tables, "sqlite");
-}
-function createPostgresOperationStrategy(tables) {
-  const common = createCommonOperationStrategy(tables, "postgres");
-  return {
-    ...common,
-    buildUpsertEmbedding(params, timestamp) {
-      return buildUpsertEmbeddingPostgres(tables, params, timestamp);
-    },
-    buildDeleteEmbedding(params) {
-      return buildDeleteEmbedding(tables, params);
-    },
-    buildGetEmbedding(graphId, nodeKind, nodeId, fieldPath) {
-      return buildGetEmbedding(tables, graphId, nodeKind, nodeId, fieldPath);
-    },
-    buildVectorSearch(params) {
-      return buildVectorSearchPostgres(tables, params);
-    }
-  };
-}
-function assertPositiveInteger(value, name) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`${name} must be a positive integer, got: ${value}`);
-  }
-}
-function assertSafeIdentifier(value, name) {
-  if (!/^[a-z0-9_]+$/i.test(value)) {
-    throw new Error(
-      `${name} must contain only alphanumeric characters and underscores, got: ${value}`
-    );
-  }
-}
-var MAX_IDENTIFIER_LENGTH = 63;
-function sanitizeIdentifier(s) {
-  return s.toLowerCase().replaceAll(/[^a-z0-9_]/g, "_");
-}
-function quoteIdentifier(value) {
-  return `"${value.replaceAll('"', '""')}"`;
-}
-function shortHash(input) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let index = 0; index < input.length; index++) {
-    const ch = input.codePointAt(index);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  const hi = (h2 >>> 0).toString(16).padStart(8, "0");
-  const lo = (h1 >>> 0).toString(16).padStart(8, "0");
-  return `${hi}${lo}`.slice(0, 8);
-}
-function generateVectorIndexName(graphId, nodeKind, fieldPath, metric = "cosine") {
-  const parts = [
-    "idx_emb",
-    sanitizeIdentifier(graphId),
-    sanitizeIdentifier(nodeKind),
-    sanitizeIdentifier(fieldPath),
-    metric
-  ];
-  const name = parts.join("_");
-  if (name.length <= MAX_IDENTIFIER_LENGTH) {
-    return name;
-  }
-  const hash = shortHash(name);
-  const truncated = name.slice(0, MAX_IDENTIFIER_LENGTH - 1 - hash.length);
-  return `${truncated}_${hash}`;
-}
-function getOperatorClass(metric) {
-  switch (metric) {
-    case "cosine": {
-      return "vector_cosine_ops";
-    }
-    case "l2": {
-      return "vector_l2_ops";
-    }
-    case "inner_product": {
-      return "vector_ip_ops";
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error("Unsupported vector metric: " + String(_exhaustive));
-    }
-  }
-}
-function escapeSqlString(value) {
-  const tag = `tg${crypto.randomUUID().replaceAll("-", "").slice(0, 8)}`;
-  return `$${tag}$${value}$${tag}$`;
-}
-async function createPostgresVectorIndex(db, options) {
-  const {
-    graphId,
-    nodeKind,
-    fieldPath,
-    dimensions,
-    embeddingsTableName = "typegraph_node_embeddings",
-    indexType = "hnsw",
-    metric = "cosine",
-    hnswM = 16,
-    hnswEfConstruction = 64,
-    ivfflatLists = 100
-  } = options;
-  assertPositiveInteger(dimensions, "dimensions");
-  assertPositiveInteger(hnswM, "hnswM");
-  assertPositiveInteger(hnswEfConstruction, "hnswEfConstruction");
-  assertPositiveInteger(ivfflatLists, "ivfflatLists");
-  const indexName = generateVectorIndexName(graphId, nodeKind, fieldPath, metric);
-  const operatorClass = getOperatorClass(metric);
-  const quotedEmbeddingsTableName = quoteIdentifier(embeddingsTableName);
-  assertSafeIdentifier(indexName, "indexName");
-  const safeGraphId = escapeSqlString(graphId);
-  const safeNodeKind = escapeSqlString(nodeKind);
-  const safeFieldPath = escapeSqlString(fieldPath);
-  let indexSql;
-  if (indexType === "hnsw") {
-    indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX IF NOT EXISTS ${indexName}
-      ON ${quotedEmbeddingsTableName}
-      USING hnsw ((embedding::vector(${dimensions})) ${operatorClass})
-      WITH (m = ${hnswM}, ef_construction = ${hnswEfConstruction})
-      WHERE graph_id = ${safeGraphId}
-        AND node_kind = ${safeNodeKind}
-        AND field_path = ${safeFieldPath}
-    `);
-  } else if (indexType === "ivfflat") {
-    indexSql = drizzleOrm.sql.raw(`
-      CREATE INDEX IF NOT EXISTS ${indexName}
-      ON ${quotedEmbeddingsTableName}
-      USING ivfflat ((embedding::vector(${dimensions})) ${operatorClass})
-      WITH (lists = ${ivfflatLists})
-      WHERE graph_id = ${safeGraphId}
-        AND node_kind = ${safeNodeKind}
-        AND field_path = ${safeFieldPath}
-    `);
-  } else {
-    return {
-      indexName,
-      success: true,
-      message: `Index type "${indexType}" not supported, skipping index creation`
-    };
-  }
-  try {
-    await db.execute(indexSql);
-    return {
-      indexName,
-      success: true,
-      message: `Created ${indexType.toUpperCase()} index "${indexName}" for ${nodeKind}.${fieldPath}`
-    };
-  } catch (error) {
-    return {
-      indexName,
-      success: false,
-      message: `Failed to create index: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-async function dropPostgresVectorIndex(db, indexName) {
-  assertSafeIdentifier(indexName, "indexName");
-  try {
-    const dropSql = drizzleOrm.sql.raw(`DROP INDEX IF EXISTS ${indexName}`);
-    await db.execute(dropSql);
-    return {
-      indexName,
-      success: true,
-      message: `Dropped index "${indexName}"`
-    };
-  } catch (error) {
-    return {
-      indexName,
-      success: false,
-      message: `Failed to drop index: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-}
-function createSqliteVectorIndex(_options) {
-  const indexName = generateVectorIndexName(
-    _options.graphId,
-    _options.nodeKind,
-    _options.fieldPath,
-    _options.metric
-  );
-  return {
-    indexName,
-    success: true,
-    message: "SQLite/sqlite-vec uses optimized internal indexing, no explicit index needed"
-  };
-}
-function dropSqliteVectorIndex(graphId, nodeKind, fieldPath, metric = "cosine") {
-  const indexName = generateVectorIndexName(graphId, nodeKind, fieldPath, metric);
-  return {
-    indexName,
-    success: true,
-    message: "SQLite/sqlite-vec does not use explicit indexes"
-  };
-}
-
-// src/backend/drizzle/execution/types.ts
-function compileQueryWithDialect(db, query, backendName) {
-  const databaseWithCompiler = db;
-  const compiler = databaseWithCompiler.dialect;
-  if (compiler === void 0) {
-    throw new Error(`${backendName} backend is missing a SQL compiler`);
-  }
-  return compiler.sqlToQuery(query);
-}
-
-exports.D1_CAPABILITIES = D1_CAPABILITIES;
-exports.POSTGRES_CAPABILITIES = POSTGRES_CAPABILITIES;
-exports.POSTGRES_ROW_MAPPER_CONFIG = POSTGRES_ROW_MAPPER_CONFIG;
-exports.SQLITE_CAPABILITIES = SQLITE_CAPABILITIES;
-exports.SQLITE_ROW_MAPPER_CONFIG = SQLITE_ROW_MAPPER_CONFIG;
-exports.compileQueryWithDialect = compileQueryWithDialect;
-exports.createCommonOperationBackend = createCommonOperationBackend;
-exports.createEdgeRowMapper = createEdgeRowMapper;
-exports.createNodeRowMapper = createNodeRowMapper;
-exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
-exports.createPostgresVectorIndex = createPostgresVectorIndex;
-exports.createSchemaVersionRowMapper = createSchemaVersionRowMapper;
-exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
-exports.createSqliteVectorIndex = createSqliteVectorIndex;
-exports.createUniqueRowMapper = createUniqueRowMapper;
-exports.dropPostgresVectorIndex = dropPostgresVectorIndex;
-exports.dropSqliteVectorIndex = dropSqliteVectorIndex;
-exports.formatPostgresTimestamp = formatPostgresTimestamp;
-exports.generateVectorIndexName = generateVectorIndexName;
-exports.nowIso = nowIso;
-//# sourceMappingURL=chunk-PW5BSBZV.cjs.map
-//# sourceMappingURL=chunk-PW5BSBZV.cjs.map