@nicia-ai/typegraph 0.1.0

package/dist/chunk-F32HCHYA.cjs

@@ -0,0 +1,680 @@
+'use strict';
+
+var chunkYM5AL65Y_cjs = require('./chunk-YM5AL65Y.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
+};
+function sqlNull(value) {
+  return value ?? drizzleOrm.sql.raw("NULL");
+}
+function buildInsertNode(tables, params, timestamp) {
+  const { nodes } = tables;
+  const propsJson = JSON.stringify(params.props);
+  const cols = 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}"`);
+  return drizzleOrm.sql`
+    INSERT INTO ${nodes} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
+      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${timestamp}, ${timestamp}
+    )
+    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 buildUpdateNode(tables, params, timestamp) {
+  const { nodes } = tables;
+  const propsJson = JSON.stringify(params.props);
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  const setParts = [
+    drizzleOrm.sql`${col(nodes.props)} = ${propsJson}`,
+    drizzleOrm.sql`${col(nodes.updatedAt)} = ${timestamp}`
+  ];
+  if (params.incrementVersion) {
+    setParts.push(drizzleOrm.sql`${col(nodes.version)} = ${col(nodes.version)} + 1`);
+  }
+  if (params.validTo !== void 0) {
+    setParts.push(drizzleOrm.sql`${col(nodes.validTo)} = ${params.validTo}`);
+  }
+  if (params.clearDeleted) {
+    setParts.push(drizzleOrm.sql`${col(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;
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  return drizzleOrm.sql`
+    UPDATE ${nodes}
+    SET ${col(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 buildInsertEdge(tables, params, timestamp) {
+  const { edges } = tables;
+  const propsJson = JSON.stringify(params.props);
+  const cols = 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}"`);
+  return drizzleOrm.sql`
+    INSERT INTO ${edges} (${cols})
+    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 buildGetEdge(tables, graphId, id) {
+  const { edges } = tables;
+  return drizzleOrm.sql`
+    SELECT * FROM ${edges}
+    WHERE ${edges.graphId} = ${graphId}
+      AND ${edges.id} = ${id}
+  `;
+}
+function buildUpdateEdge(tables, params, timestamp) {
+  const { edges } = tables;
+  const propsJson = JSON.stringify(params.props);
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  if (params.validTo !== void 0) {
+    return drizzleOrm.sql`
+      UPDATE ${edges}
+      SET ${col(edges.props)} = ${propsJson},
+          ${col(edges.validTo)} = ${params.validTo},
+          ${col(edges.updatedAt)} = ${timestamp}
+      WHERE ${edges.graphId} = ${params.graphId}
+        AND ${edges.id} = ${params.id}
+        AND ${edges.deletedAt} IS NULL
+      RETURNING *
+    `;
+  }
+  return drizzleOrm.sql`
+    UPDATE ${edges}
+    SET ${col(edges.props)} = ${propsJson},
+        ${col(edges.updatedAt)} = ${timestamp}
+    WHERE ${edges.graphId} = ${params.graphId}
+      AND ${edges.id} = ${params.id}
+      AND ${edges.deletedAt} IS NULL
+    RETURNING *
+  `;
+}
+function buildDeleteEdge(tables, params, timestamp) {
+  const { edges } = tables;
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  return drizzleOrm.sql`
+    UPDATE ${edges}
+    SET ${col(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 buildInsertUniqueSqlite(tables, params) {
+  const { uniques } = tables;
+  const cols = 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 conflictCols = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`);
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  return drizzleOrm.sql`
+    INSERT INTO ${uniques} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictCols})
+    DO UPDATE SET
+      ${col(uniques.nodeId)} = CASE
+        WHEN ${col(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${col(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${col(uniques.nodeId)}
+      END,
+      ${col(uniques.concreteKind)} = CASE
+        WHEN ${col(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${col(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${col(uniques.concreteKind)}
+      END,
+      ${col(uniques.deletedAt)} = CASE
+        WHEN ${col(uniques.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${col(uniques.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${col(uniques.deletedAt)}
+      END
+    RETURNING ${col(uniques.nodeId)} as node_id
+  `;
+}
+function buildInsertUniquePostgres(tables, params) {
+  const { uniques } = tables;
+  const cols = 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 conflictCols = drizzleOrm.sql.raw(`"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`);
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  const tableName = drizzleOrm.getTableName(uniques);
+  const existingCol = (c) => drizzleOrm.sql.raw(`"${tableName}"."${c.name}"`);
+  return drizzleOrm.sql`
+    INSERT INTO ${uniques} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
+      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
+    )
+    ON CONFLICT (${conflictCols})
+    DO UPDATE SET
+      ${col(uniques.nodeId)} = CASE
+        WHEN ${existingCol(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${existingCol(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${existingCol(uniques.nodeId)}
+      END,
+      ${col(uniques.concreteKind)} = CASE
+        WHEN ${existingCol(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${existingCol(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${existingCol(uniques.concreteKind)}
+      END,
+      ${col(uniques.deletedAt)} = CASE
+        WHEN ${existingCol(uniques.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${existingCol(uniques.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${existingCol(uniques.deletedAt)}
+      END
+    RETURNING ${col(uniques.nodeId)} as node_id
+  `;
+}
+function buildInsertUnique(tables, dialect, params) {
+  if (dialect === "sqlite") {
+    return buildInsertUniqueSqlite(tables, params);
+  }
+  return buildInsertUniquePostgres(tables, params);
+}
+function buildDeleteUnique(tables, params, timestamp) {
+  const { uniques } = tables;
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  return drizzleOrm.sql`
+    UPDATE ${uniques}
+    SET ${col(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 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})
+        OR
+        (${edges.toKind} = ${params.nodeKind} AND ${edges.toId} = ${params.nodeId})
+      )
+  `;
+}
+function buildFindNodesByKind(tables, params) {
+  const { nodes } = tables;
+  const excludeDeleted = params.excludeDeleted ?? true;
+  const baseCondition = excludeDeleted ? drizzleOrm.sql`${nodes.graphId} = ${params.graphId} AND ${nodes.kind} = ${params.kind} AND ${nodes.deletedAt} IS NULL` : drizzleOrm.sql`${nodes.graphId} = ${params.graphId} AND ${nodes.kind} = ${params.kind}`;
+  if (params.limit !== void 0 && params.offset !== void 0) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${nodes}
+      WHERE ${baseCondition}
+      ORDER BY ${nodes.createdAt} DESC
+      LIMIT ${params.limit} OFFSET ${params.offset}
+    `;
+  }
+  if (params.limit !== void 0) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${nodes}
+      WHERE ${baseCondition}
+      ORDER BY ${nodes.createdAt} DESC
+      LIMIT ${params.limit}
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT * FROM ${nodes}
+    WHERE ${baseCondition}
+    ORDER BY ${nodes.createdAt} DESC
+  `;
+}
+function buildCountNodesByKind(tables, params) {
+  const { nodes } = tables;
+  const excludeDeleted = params.excludeDeleted ?? true;
+  if (excludeDeleted) {
+    return drizzleOrm.sql`
+      SELECT COUNT(*) as count FROM ${nodes}
+      WHERE ${nodes.graphId} = ${params.graphId}
+        AND ${nodes.kind} = ${params.kind}
+        AND ${nodes.deletedAt} IS NULL
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT COUNT(*) as count FROM ${nodes}
+    WHERE ${nodes.graphId} = ${params.graphId}
+      AND ${nodes.kind} = ${params.kind}
+  `;
+}
+function buildFindEdgesByKind(tables, params) {
+  const { edges } = tables;
+  const excludeDeleted = params.excludeDeleted ?? true;
+  const conditions = [
+    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges.kind} = ${params.kind}`
+  ];
+  if (excludeDeleted) {
+    conditions.push(drizzleOrm.sql`${edges.deletedAt} IS NULL`);
+  }
+  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 excludeDeleted = params.excludeDeleted ?? true;
+  const conditions = [
+    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+    drizzleOrm.sql`${edges.kind} = ${params.kind}`
+  ];
+  if (excludeDeleted) {
+    conditions.push(drizzleOrm.sql`${edges.deletedAt} IS NULL`);
+  }
+  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 buildInsertSchemaSqlite(tables, params, timestamp) {
+  const { schemaVersions } = tables;
+  const schemaDocumentJson = JSON.stringify(params.schemaDoc);
+  const isActiveValue = params.isActive ? drizzleOrm.sql.raw("1") : drizzleOrm.sql.raw("0");
+  const cols = 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} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.version},
+      ${params.schemaHash}, ${schemaDocumentJson},
+      ${timestamp}, ${isActiveValue}
+    )
+    RETURNING *
+  `;
+}
+function buildInsertSchemaPostgres(tables, params, timestamp) {
+  const { schemaVersions } = tables;
+  const schemaDocumentJson = JSON.stringify(params.schemaDoc);
+  const isActiveValue = params.isActive ? drizzleOrm.sql.raw("true") : drizzleOrm.sql.raw("false");
+  const cols = 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} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.version},
+      ${params.schemaHash}, ${schemaDocumentJson},
+      ${timestamp}, ${isActiveValue}
+    )
+    RETURNING *
+  `;
+}
+function buildInsertSchema(tables, params, timestamp, dialect = "sqlite") {
+  if (dialect === "postgres") {
+    return buildInsertSchemaPostgres(tables, params, timestamp);
+  }
+  return buildInsertSchemaSqlite(tables, params, timestamp);
+}
+function buildGetActiveSchema(tables, graphId, dialect = "sqlite") {
+  const { schemaVersions } = tables;
+  const adapter = chunkYM5AL65Y_cjs.getDialect(dialect);
+  return drizzleOrm.sql`
+    SELECT * FROM ${schemaVersions}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+      AND ${schemaVersions.isActive} = ${adapter.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 adapter = chunkYM5AL65Y_cjs.getDialect(dialect);
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  const deactivateAll = drizzleOrm.sql`
+    UPDATE ${schemaVersions}
+    SET ${col(schemaVersions.isActive)} = ${adapter.booleanLiteral(false)}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+  `;
+  const activateVersion = drizzleOrm.sql`
+    UPDATE ${schemaVersions}
+    SET ${col(schemaVersions.isActive)} = ${adapter.booleanLiteral(true)}
+    WHERE ${schemaVersions.graphId} = ${graphId}
+      AND ${schemaVersions.version} = ${version}
+  `;
+  return { deactivateAll, activateVersion };
+}
+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 cols = 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 conflictCols = drizzleOrm.sql.raw(
+    `"${embeddings.graphId.name}", "${embeddings.nodeKind.name}", "${embeddings.nodeId.name}", "${embeddings.fieldPath.name}"`
+  );
+  const col = (c) => drizzleOrm.sql.raw(`"${c.name}"`);
+  return drizzleOrm.sql`
+    INSERT INTO ${embeddings} (${cols})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.fieldPath},
+      ${embeddingLiteral}::vector, ${params.dimensions}, ${timestamp}, ${timestamp}
+    )
+    ON CONFLICT (${conflictCols})
+    DO UPDATE SET
+      ${col(embeddings.embedding)} = ${embeddingLiteral}::vector,
+      ${col(embeddings.dimensions)} = ${params.dimensions},
+      ${col(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 vectorParam = drizzleOrm.sql`${queryLiteral}::vector`;
+  switch (metric) {
+    case "cosine": {
+      return drizzleOrm.sql`(${embeddingColumn} <=> ${vectorParam})`;
+    }
+    case "l2": {
+      return drizzleOrm.sql`(${embeddingColumn} <-> ${vectorParam})`;
+    }
+    case "inner_product": {
+      return drizzleOrm.sql`(${embeddingColumn} <#> ${vectorParam})`;
+    }
+  }
+}
+function buildVectorSearchPostgres(tables, params) {
+  const { embeddings } = tables;
+  const queryLiteral = formatEmbeddingLiteral(params.queryEmbedding);
+  const embeddingColumn = drizzleOrm.sql`${embeddings.embedding}`;
+  const distanceExpr = 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) {
+    if (!Number.isFinite(params.minScore)) {
+      throw new TypeError(`minScore must be a finite number, got: ${params.minScore}`);
+    }
+    const threshold = 1 - params.minScore;
+    conditions.push(drizzleOrm.sql`${distanceExpr} <= ${threshold}`);
+  }
+  if (!Number.isInteger(params.limit) || params.limit <= 0) {
+    throw new Error(`limit must be a positive integer, got: ${params.limit}`);
+  }
+  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
+  return drizzleOrm.sql`
+    SELECT
+      ${embeddings.nodeId} as node_id,
+      (1 - (${distanceExpr})) as score
+    FROM ${embeddings}
+    WHERE ${whereClause}
+    ORDER BY ${distanceExpr} ASC
+    LIMIT ${params.limit}
+  `;
+}
+
+exports.D1_CAPABILITIES = D1_CAPABILITIES;
+exports.POSTGRES_CAPABILITIES = POSTGRES_CAPABILITIES;
+exports.SQLITE_CAPABILITIES = SQLITE_CAPABILITIES;
+exports.buildCheckUnique = buildCheckUnique;
+exports.buildCountEdgesByKind = buildCountEdgesByKind;
+exports.buildCountEdgesFrom = buildCountEdgesFrom;
+exports.buildCountNodesByKind = buildCountNodesByKind;
+exports.buildDeleteEdge = buildDeleteEdge;
+exports.buildDeleteEmbedding = buildDeleteEmbedding;
+exports.buildDeleteNode = buildDeleteNode;
+exports.buildDeleteUnique = buildDeleteUnique;
+exports.buildEdgeExistsBetween = buildEdgeExistsBetween;
+exports.buildFindEdgesByKind = buildFindEdgesByKind;
+exports.buildFindEdgesConnectedTo = buildFindEdgesConnectedTo;
+exports.buildFindNodesByKind = buildFindNodesByKind;
+exports.buildGetActiveSchema = buildGetActiveSchema;
+exports.buildGetEdge = buildGetEdge;
+exports.buildGetEmbedding = buildGetEmbedding;
+exports.buildGetNode = buildGetNode;
+exports.buildGetSchemaVersion = buildGetSchemaVersion;
+exports.buildHardDeleteEdge = buildHardDeleteEdge;
+exports.buildHardDeleteEmbeddingsByNode = buildHardDeleteEmbeddingsByNode;
+exports.buildHardDeleteNode = buildHardDeleteNode;
+exports.buildHardDeleteUniquesByNode = buildHardDeleteUniquesByNode;
+exports.buildInsertEdge = buildInsertEdge;
+exports.buildInsertNode = buildInsertNode;
+exports.buildInsertSchema = buildInsertSchema;
+exports.buildInsertUnique = buildInsertUnique;
+exports.buildSetActiveSchema = buildSetActiveSchema;
+exports.buildUpdateEdge = buildUpdateEdge;
+exports.buildUpdateNode = buildUpdateNode;
+exports.buildUpsertEmbeddingPostgres = buildUpsertEmbeddingPostgres;
+exports.buildVectorSearchPostgres = buildVectorSearchPostgres;
+//# sourceMappingURL=chunk-F32HCHYA.cjs.map
+//# sourceMappingURL=chunk-F32HCHYA.cjs.map