@nicia-ai/typegraph 0.2.0 → 0.3.0

package/dist/chunk-SFY2PPOY.cjs

@@ -0,0 +1,1469 @@
+'use strict';
+
+var chunkOYL2SGBD_cjs = require('./chunk-OYL2SGBD.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 chunkOYL2SGBD_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 chunkOYL2SGBD_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 chunkOYL2SGBD_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 chunkOYL2SGBD_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 chunkOYL2SGBD_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 chunkOYL2SGBD_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 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 chunkOYL2SGBD_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);
+    }
+  };
+}
+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;
+  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 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,
+  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);
+    }
+  };
+}
+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-SFY2PPOY.cjs.map
+//# sourceMappingURL=chunk-SFY2PPOY.cjs.map