@nicia-ai/typegraph 0.2.0 → 0.3.0

package/dist/chunk-HXAPXPZH.cjs

@@ -1,680 +0,0 @@
-'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-HXAPXPZH.cjs.map
-//# sourceMappingURL=chunk-HXAPXPZH.cjs.map