@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/chunk-S3SDEQMC.js

@@ -1,532 +0,0 @@
-import { edgeCardinalityClaimTarget, EDGE_CARDINALITY_SPECS, edgeCardinalityAxesForKind } from './chunk-YA36ABIL.js';
-import { rowPropsToJsonText } from './chunk-PALYTHGM.js';
-import { claimOwnerMatchesSql } from './chunk-5LKOVCPP.js';
-import { canonicalizeDatabaseTimestamp } from './chunk-K46SDNQD.js';
-import { sql as sql$1 } from './chunk-46UGOVRW.js';
-import { DatabaseOperationError } from './chunk-YDEJQWOL.js';
-import { getTableName, sql } from 'drizzle-orm';
-
-// src/backend/row-mappers.ts
-function asString(value, field) {
-  if (typeof value !== "string") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be string, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asNumber(value, field) {
-  if (typeof value !== "number") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be number, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-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 normalizeRowTimestamp(value, field) {
-  if (value === null || value === void 0) return void 0;
-  const canonical = canonicalizeDatabaseTimestamp(value);
-  if (canonical === void 0) {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be a database timestamp, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return canonical;
-}
-function normalizeRequiredRowTimestamp(value, field) {
-  const timestamp = normalizeRowTimestamp(value, field);
-  if (timestamp === void 0) {
-    throw new DatabaseOperationError(`Expected non-null ${field} timestamp`, {
-      operation: "select",
-      entity: "row"
-    });
-  }
-  return timestamp;
-}
-function coerceNumericScore(value) {
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(value);
-  if (Number.isNaN(parsed)) {
-    throw new TypeError(
-      `Backend returned non-numeric fulltext score: ${JSON.stringify(value)}`
-    );
-  }
-  return parsed;
-}
-function normalizeJsonColumn(value) {
-  if (typeof value === "string") return value;
-  if (value !== null && typeof value === "object") {
-    return value;
-  }
-  return JSON.stringify(value ?? {});
-}
-var SQLITE_ROW_MAPPER_CONFIG = {
-  normalizeJson: (value) => {
-    if (typeof value !== "string") {
-      throw new DatabaseOperationError(
-        `Expected JSON column to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  }
-};
-var POSTGRES_ROW_MAPPER_CONFIG = {
-  normalizeJson: normalizeJsonColumn
-};
-function createNodeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row["graph_id"], "graph_id"),
-    kind: asString(row["kind"], "kind"),
-    id: asString(row["id"], "id"),
-    props: config.normalizeJson(row["props"]),
-    version: asNumber(row["version"], "version"),
-    valid_from: normalizeRowTimestamp(row["valid_from"], "valid_from"),
-    valid_to: normalizeRowTimestamp(row["valid_to"], "valid_to"),
-    created_at: normalizeRequiredRowTimestamp(row["created_at"], "created_at"),
-    updated_at: normalizeRequiredRowTimestamp(row["updated_at"], "updated_at"),
-    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
-  });
-}
-function createEdgeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row["graph_id"], "graph_id"),
-    id: asString(row["id"], "id"),
-    kind: asString(row["kind"], "kind"),
-    from_kind: asString(row["from_kind"], "from_kind"),
-    from_id: asString(row["from_id"], "from_id"),
-    to_kind: asString(row["to_kind"], "to_kind"),
-    to_id: asString(row["to_id"], "to_id"),
-    props: config.normalizeJson(row["props"]),
-    valid_from: normalizeRowTimestamp(row["valid_from"], "valid_from"),
-    valid_to: normalizeRowTimestamp(row["valid_to"], "valid_to"),
-    created_at: normalizeRequiredRowTimestamp(row["created_at"], "created_at"),
-    updated_at: normalizeRequiredRowTimestamp(row["updated_at"], "updated_at"),
-    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
-  });
-}
-function mapUniqueRow(row) {
-  return {
-    graph_id: asString(row["graph_id"], "graph_id"),
-    node_kind: asString(row["node_kind"], "node_kind"),
-    constraint_name: asString(row["constraint_name"], "constraint_name"),
-    key: asString(row["key"], "key"),
-    node_id: asString(row["node_id"], "node_id"),
-    concrete_kind: asString(row["concrete_kind"], "concrete_kind"),
-    deleted_at: normalizeRowTimestamp(row["deleted_at"], "deleted_at")
-  };
-}
-function createUniqueRowMapper(_config) {
-  return mapUniqueRow;
-}
-function createSchemaVersionRowMapper(config) {
-  return (row) => {
-    const isActiveValue = row["is_active"];
-    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
-    return {
-      graph_id: asString(row["graph_id"], "graph_id"),
-      version: asNumber(row["version"], "version"),
-      schema_hash: asString(row["schema_hash"], "schema_hash"),
-      schema_doc: rowPropsToJsonText(config.normalizeJson(row["schema_doc"])),
-      created_at: normalizeRequiredRowTimestamp(
-        row["created_at"],
-        "created_at"
-      ),
-      is_active: isActive
-    };
-  };
-}
-function primaryKeyConstraintNames(relation, keyColumns) {
-  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
-}
-function nodePrimaryKeyConstraint(nodes) {
-  const relation = getTableName(nodes);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      nodes.graphId.name,
-      nodes.kind.name,
-      nodes.id.name
-    ])
-  };
-}
-function edgePrimaryKeyConstraint(edges) {
-  const relation = getTableName(edges);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      edges.graphId.name,
-      edges.id.name
-    ])
-  };
-}
-function sqlNull(value) {
-  return value ?? sql.raw("NULL");
-}
-function expectedValidFromPredicate(column, expected) {
-  if (expected === void 0) return sql.empty();
-  if (expected === null) return sql` AND ${column} IS NULL`;
-  return sql` AND ${column} = ${expected}`;
-}
-function quotedColumn(column) {
-  return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function quotedTableName(tableName) {
-  return sql.raw(`"${tableName.replaceAll('"', '""')}"`);
-}
-var CODE_POINT_ORDER_BUILDERS = {
-  postgres: (value) => sql`${value} COLLATE "C"`,
-  sqlite: (value) => value
-};
-function codePointOrderKey(column, dialect) {
-  return CODE_POINT_ORDER_BUILDERS[dialect](column);
-}
-function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso2) {
-  return sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso2}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso2})`;
-}
-function nodeColumnList(nodes) {
-  return 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 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}"`
-  );
-}
-function qualified(tableName, column) {
-  return sql.raw(`"${tableName}"."${column.name}"`);
-}
-function buildLockEdgeClaims(tables, entries, timestamp) {
-  const { edgeClaims } = tables;
-  const claimsName = getTableName(edgeClaims);
-  const columns = sql.raw(
-    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}", "${edgeClaims.edgeId.name}", "${edgeClaims.updatedAt.name}"`
-  );
-  const conflictColumns = sql.raw(
-    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}"`
-  );
-  const valueRows = sql.join(
-    entries.map((entry) => {
-      const target = edgeCardinalityClaimTarget(entry);
-      return sql`(${entry.graphId}, ${target.axis}, ${target.key}, ${entry.edgeId}, ${timestamp})`;
-    }),
-    sql`, `
-  );
-  return sql`
-    INSERT INTO ${edgeClaims} (${columns})
-    VALUES ${valueRows}
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET ${quotedColumn(edgeClaims.updatedAt)} = ${qualified(claimsName, edgeClaims.updatedAt)}
-    RETURNING
-      ${quotedColumn(edgeClaims.axis)} as axis,
-      ${quotedColumn(edgeClaims.key)} as key,
-      ${quotedColumn(edgeClaims.edgeId)} as holder_edge_id
-  `;
-}
-function buildTakeOverEdgeClaim(tables, params, timestamp) {
-  const { edgeClaims, edges } = tables;
-  const claimsName = getTableName(edgeClaims);
-  const edgesName = getTableName(edges);
-  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];
-  const target = edgeCardinalityClaimTarget(params);
-  const toEndpointTerms = spec.keyShape === "fromAndTo" ? sql` AND ${qualified(edgesName, edges.toKind)} = ${params.toKind} AND ${qualified(edgesName, edges.toId)} = ${params.toId}` : sql``;
-  const activeTerm = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified(edgesName, edges.validTo)} IS NULL` : sql``;
-  return sql`
-    UPDATE ${edgeClaims}
-    SET ${quotedColumn(edgeClaims.edgeId)} = ${params.edgeId},
-        ${quotedColumn(edgeClaims.updatedAt)} = ${timestamp}
-    WHERE ${qualified(claimsName, edgeClaims.graphId)} = ${params.graphId}
-      AND ${qualified(claimsName, edgeClaims.axis)} = ${target.axis}
-      AND ${qualified(claimsName, edgeClaims.key)} = ${target.key}
-      AND ${qualified(claimsName, edgeClaims.edgeId)} <> ${params.edgeId}
-      AND NOT EXISTS (
-        SELECT 1 FROM ${edges}
-        WHERE ${qualified(edgesName, edges.graphId)} = ${qualified(claimsName, edgeClaims.graphId)}
-          AND ${qualified(edgesName, edges.id)} = ${qualified(claimsName, edgeClaims.edgeId)}
-          AND ${qualified(edgesName, edges.deletedAt)} IS NULL
-          AND ${qualified(edgesName, edges.kind)} = ${params.edgeKind}
-          AND ${qualified(edgesName, edges.fromKind)} = ${params.fromKind}
-          AND ${qualified(edgesName, edges.fromId)} = ${params.fromId}${toEndpointTerms}${activeTerm}
-      )
-    RETURNING ${quotedColumn(edgeClaims.edgeId)} as holder_edge_id
-  `;
-}
-function buildPurgeEdgeClaims(tables, params) {
-  const { edgeClaims } = tables;
-  return sql`
-    DELETE FROM ${edgeClaims}
-    WHERE ${edgeClaims.graphId} = ${params.graphId}
-      AND ${edgeClaims.edgeId} IN (${sql.join(
-    params.edgeIds.map((edgeId) => sql`${edgeId}`),
-    sql`, `
-  )})
-  `;
-}
-function buildHardDeleteEdgeClaimsByEdgeKind(edgeClaimsTableName, params) {
-  const axes = edgeCardinalityAxesForKind(params.edgeKind).map(
-    (axis) => sql$1`${axis}`
-  );
-  return sql$1`DELETE FROM ${sql$1.identifier(edgeClaimsTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("axis")} IN (${sql$1.join(axes, sql$1`, `)})`;
-}
-function buildHardDeleteEdgeClaimsByNodeKind(edgeClaimsTableName, edgesTableName, params) {
-  return sql$1`DELETE FROM ${sql$1.identifier(edgeClaimsTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("edge_id")} IN (SELECT ${sql$1.identifier("id")} FROM ${sql$1.identifier(edgesTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND (${sql$1.identifier("from_kind")} = ${params.nodeKind} OR ${sql$1.identifier("to_kind")} = ${params.nodeKind}))`;
-}
-function boundOwnerColumn(uniques, params) {
-  return (column) => column.name === uniques.nodeId.name ? sql`${params.nodeId}` : sql`${params.concreteKind}`;
-}
-function buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
-  const columns = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const ownerMatches = claimOwnerMatchesSql(
-    (column) => quotedColumn(column),
-    boundOwnerColumn(uniques, params),
-    uniques
-  );
-  return sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${ownerMatches} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${ownerMatches} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${ownerMatches} THEN NULL
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques.deletedAt)}
-      END
-    RETURNING
-      ${quotedColumn(uniques.nodeId)} as node_id,
-      ${quotedColumn(uniques.concreteKind)} as concrete_kind
-  `;
-}
-function buildInsertUniquePostgres(tables, params) {
-  const { uniques } = tables;
-  const columns = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
-  const ownerMatches = claimOwnerMatchesSql(
-    (column) => existingColumn(column),
-    boundOwnerColumn(uniques, params),
-    uniques
-  );
-  return sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${ownerMatches} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${ownerMatches} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${ownerMatches} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING
-      ${quotedColumn(uniques.nodeId)} as node_id,
-      ${quotedColumn(uniques.concreteKind)} as concrete_kind
-  `;
-}
-var UNIQUE_INSERT_BUILDERS = {
-  postgres: buildInsertUniquePostgres,
-  sqlite: buildInsertUniqueSqlite
-};
-function buildInsertUnique(tables, dialect, params) {
-  const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables, params);
-}
-function buildInsertUniqueBatch(tables, dialect, entries) {
-  const { uniques } = tables;
-  const columns = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => {
-    switch (dialect) {
-      case "postgres": {
-        return sql.raw(`"${tableName}"."${column.name}"`);
-      }
-      case "sqlite": {
-        return sql.raw(`"${column.name}"`);
-      }
-      default: {
-        return dialect;
-      }
-    }
-  };
-  const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
-  const ownerMatches = claimOwnerMatchesSql(
-    (column) => existingColumn(column),
-    (column) => excludedColumn(column),
-    uniques
-  );
-  const valueRows = sql.join(
-    entries.map(
-      (params) => sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")})`
-    ),
-    sql`, `
-  );
-  return sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES ${valueRows}
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${ownerMatches} THEN ${excludedColumn(uniques.nodeId)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.nodeId)}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${ownerMatches} THEN ${excludedColumn(uniques.concreteKind)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.concreteKind)}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${ownerMatches} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING
-      ${quotedColumn(uniques.nodeKind)} as node_kind,
-      ${quotedColumn(uniques.constraintName)} as constraint_name,
-      ${quotedColumn(uniques.key)} as key,
-      ${quotedColumn(uniques.nodeId)} as node_id,
-      ${quotedColumn(uniques.concreteKind)} as concrete_kind
-  `;
-}
-function buildDeleteUnique(tables, params, timestamp) {
-  const { uniques } = tables;
-  const axisTerm = params.nodeKind === void 0 ? sql`` : sql` AND ${uniques.nodeKind} = ${params.nodeKind}`;
-  return sql`
-    UPDATE ${uniques}
-    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.concreteKind} = ${params.concreteKind}
-      AND ${uniques.nodeId} = ${params.nodeId}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}${axisTerm}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteUniquesByNode(tables, graphId, concreteKind, nodeId) {
-  return buildHardDeleteUniquesByNodeIds(tables, {
-    graphId,
-    concreteKind,
-    nodeIds: [nodeId]
-  });
-}
-function buildHardDeleteUniquesByNodeIds(tables, params) {
-  const { uniques } = tables;
-  return sql`
-    DELETE FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.concreteKind} = ${params.concreteKind}
-      AND ${uniques.nodeId} IN (${sql.join(
-    params.nodeIds.map((nodeId) => sql`${nodeId}`),
-    sql`, `
-  )})
-  `;
-}
-function buildHardDeleteUniquesByConcreteKind(uniquesTableName, params) {
-  return sql$1`DELETE FROM ${sql$1.identifier(uniquesTableName)} WHERE ${sql$1.identifier("graph_id")} = ${params.graphId} AND ${sql$1.identifier("concrete_kind")} = ${params.concreteKind}`;
-}
-function buildCheckUnique(tables, params) {
-  const { uniques } = tables;
-  if (params.includeDeleted) {
-    return sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} = ${params.key}
-    `;
-  }
-  return sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildCheckUniqueBatch(tables, params) {
-  const { uniques } = tables;
-  const keyPlaceholders = sql.join(
-    params.keys.map((key) => sql`${key}`),
-    sql`, `
-  );
-  if (params.includeDeleted) {
-    return sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} IN (${keyPlaceholders})
-    `;
-  }
-  return sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} IN (${keyPlaceholders})
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-
-export { POSTGRES_ROW_MAPPER_CONFIG, SQLITE_ROW_MAPPER_CONFIG, buildCheckUnique, buildCheckUniqueBatch, buildDeleteUnique, buildHardDeleteEdgeClaimsByEdgeKind, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteUniquesByNode, buildHardDeleteUniquesByNodeIds, buildInsertUnique, buildInsertUniqueBatch, buildLockEdgeClaims, buildPurgeEdgeClaims, buildTakeOverEdgeClaim, codePointOrderKey, coerceNumericScore, createEdgeRowMapper, createNodeRowMapper, createSchemaVersionRowMapper, createUniqueRowMapper, edgeColumnList, edgePrimaryKeyConstraint, expectedValidFromPredicate, formatPostgresTimestamp, liveNodeIdsSubquery, nodeColumnList, nodePrimaryKeyConstraint, normalizeRequiredRowTimestamp, normalizeRowTimestamp, nowIso, quotedColumn, quotedTableName, sqlNull };
-//# sourceMappingURL=chunk-S3SDEQMC.js.map
-//# sourceMappingURL=chunk-S3SDEQMC.js.map