@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/chunk-EH3JZJUM.cjs

@@ -0,0 +1,567 @@
+'use strict';
+
+var chunk7PRMDZIA_cjs = require('./chunk-7PRMDZIA.cjs');
+var chunkGHZPZNFC_cjs = require('./chunk-GHZPZNFC.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkM5MSP3BI_cjs = require('./chunk-M5MSP3BI.cjs');
+var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
+var drizzleOrm = require('drizzle-orm');
+
+// src/backend/row-mappers.ts
+function asString(value, field) {
+  if (typeof value !== "string") {
+    throw new chunkX4GDXBOP_cjs.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 chunkX4GDXBOP_cjs.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 = chunkM5MSP3BI_cjs.canonicalizeDatabaseTimestamp(value);
+  if (canonical === void 0) {
+    throw new chunkX4GDXBOP_cjs.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 chunkX4GDXBOP_cjs.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 chunkX4GDXBOP_cjs.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: chunkGHZPZNFC_cjs.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 = drizzleOrm.getTableName(nodes);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      nodes.graphId.name,
+      nodes.kind.name,
+      nodes.id.name
+    ])
+  };
+}
+function edgePrimaryKeyConstraint(edges) {
+  const relation = drizzleOrm.getTableName(edges);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      edges.graphId.name,
+      edges.id.name
+    ])
+  };
+}
+function sqlNull(value) {
+  return value ?? drizzleOrm.sql.raw("NULL");
+}
+function expectedValidFromPredicate(column, expected) {
+  if (expected === void 0) return drizzleOrm.sql.empty();
+  if (expected === null) return drizzleOrm.sql` AND ${column} IS NULL`;
+  return drizzleOrm.sql` AND ${column} = ${expected}`;
+}
+function quotedColumn(column) {
+  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function quotedTableName(tableName) {
+  return drizzleOrm.sql.raw(`"${tableName.replaceAll('"', '""')}"`);
+}
+var CODE_POINT_ORDER_BUILDERS = {
+  postgres: (value) => drizzleOrm.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 drizzleOrm.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 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}"`
+  );
+}
+function qualified(tableName, column) {
+  return drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
+}
+function buildLockEdgeClaims(tables, entries, timestamp) {
+  const { edgeClaims } = tables;
+  const claimsName = drizzleOrm.getTableName(edgeClaims);
+  const columns = drizzleOrm.sql.raw(
+    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}", "${edgeClaims.edgeId.name}", "${edgeClaims.updatedAt.name}"`
+  );
+  const conflictColumns = drizzleOrm.sql.raw(
+    `"${edgeClaims.graphId.name}", "${edgeClaims.axis.name}", "${edgeClaims.key.name}"`
+  );
+  const valueRows = drizzleOrm.sql.join(
+    entries.map((entry) => {
+      const target = chunk7PRMDZIA_cjs.edgeCardinalityClaimTarget(entry);
+      return drizzleOrm.sql`(${entry.graphId}, ${target.axis}, ${target.key}, ${entry.edgeId}, ${timestamp})`;
+    }),
+    drizzleOrm.sql`, `
+  );
+  return drizzleOrm.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 = drizzleOrm.getTableName(edgeClaims);
+  const edgesName = drizzleOrm.getTableName(edges);
+  const spec = chunk7PRMDZIA_cjs.EDGE_CARDINALITY_SPECS[params.cardinality];
+  const target = chunk7PRMDZIA_cjs.edgeCardinalityClaimTarget(params);
+  const toEndpointTerms = spec.keyShape === "fromAndTo" ? drizzleOrm.sql` AND ${qualified(edgesName, edges.toKind)} = ${params.toKind} AND ${qualified(edgesName, edges.toId)} = ${params.toId}` : drizzleOrm.sql``;
+  const activeTerm = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified(edgesName, edges.validTo)} IS NULL` : drizzleOrm.sql``;
+  return drizzleOrm.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 drizzleOrm.sql`
+    DELETE FROM ${edgeClaims}
+    WHERE ${edgeClaims.graphId} = ${params.graphId}
+      AND ${edgeClaims.edgeId} IN (${drizzleOrm.sql.join(
+    params.edgeIds.map((edgeId) => drizzleOrm.sql`${edgeId}`),
+    drizzleOrm.sql`, `
+  )})
+  `;
+}
+function buildHardDeleteEdgeClaimsByEdgeKind(edgeClaimsTableName, params) {
+  const axes = chunk7PRMDZIA_cjs.edgeCardinalityAxesForKind(params.edgeKind).map(
+    (axis) => chunkOJHD3LXJ_cjs.sql`${axis}`
+  );
+  return chunkOJHD3LXJ_cjs.sql`DELETE FROM ${chunkOJHD3LXJ_cjs.sql.identifier(edgeClaimsTableName)} WHERE ${chunkOJHD3LXJ_cjs.sql.identifier("graph_id")} = ${params.graphId} AND ${chunkOJHD3LXJ_cjs.sql.identifier("axis")} IN (${chunkOJHD3LXJ_cjs.sql.join(axes, chunkOJHD3LXJ_cjs.sql`, `)})`;
+}
+function buildHardDeleteEdgeClaimsByNodeKind(edgeClaimsTableName, edgesTableName, params) {
+  return chunkOJHD3LXJ_cjs.sql`DELETE FROM ${chunkOJHD3LXJ_cjs.sql.identifier(edgeClaimsTableName)} WHERE ${chunkOJHD3LXJ_cjs.sql.identifier("graph_id")} = ${params.graphId} AND ${chunkOJHD3LXJ_cjs.sql.identifier("edge_id")} IN (SELECT ${chunkOJHD3LXJ_cjs.sql.identifier("id")} FROM ${chunkOJHD3LXJ_cjs.sql.identifier(edgesTableName)} WHERE ${chunkOJHD3LXJ_cjs.sql.identifier("graph_id")} = ${params.graphId} AND (${chunkOJHD3LXJ_cjs.sql.identifier("from_kind")} = ${params.nodeKind} OR ${chunkOJHD3LXJ_cjs.sql.identifier("to_kind")} = ${params.nodeKind}))`;
+}
+function boundOwnerColumn(uniques, params) {
+  return (column) => column.name === uniques.nodeId.name ? drizzleOrm.sql`${params.nodeId}` : drizzleOrm.sql`${params.concreteKind}`;
+}
+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}"`
+  );
+  const ownerMatches = chunkLLVOQOWE_cjs.claimOwnerMatchesSql(
+    (column) => quotedColumn(column),
+    boundOwnerColumn(uniques, params),
+    uniques
+  );
+  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 ${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 = 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}"`);
+  const ownerMatches = chunkLLVOQOWE_cjs.claimOwnerMatchesSql(
+    (column) => existingColumn(column),
+    boundOwnerColumn(uniques, params),
+    uniques
+  );
+  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 ${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 = 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) => {
+    switch (dialect) {
+      case "postgres": {
+        return drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
+      }
+      case "sqlite": {
+        return drizzleOrm.sql.raw(`"${column.name}"`);
+      }
+      default: {
+        return dialect;
+      }
+    }
+  };
+  const excludedColumn = (column) => drizzleOrm.sql.raw(`excluded."${column.name}"`);
+  const ownerMatches = chunkLLVOQOWE_cjs.claimOwnerMatchesSql(
+    (column) => existingColumn(column),
+    (column) => excludedColumn(column),
+    uniques
+  );
+  const valueRows = drizzleOrm.sql.join(
+    entries.map(
+      (params) => drizzleOrm.sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")})`
+    ),
+    drizzleOrm.sql`, `
+  );
+  return drizzleOrm.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 ? drizzleOrm.sql`` : drizzleOrm.sql` AND ${uniques.nodeKind} = ${params.nodeKind}`;
+  return drizzleOrm.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 drizzleOrm.sql`
+    DELETE FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.concreteKind} = ${params.concreteKind}
+      AND ${uniques.nodeId} IN (${drizzleOrm.sql.join(
+    params.nodeIds.map((nodeId) => drizzleOrm.sql`${nodeId}`),
+    drizzleOrm.sql`, `
+  )})
+  `;
+}
+function buildHardDeleteUniquesByConcreteKind(uniquesTableName, params) {
+  return chunkOJHD3LXJ_cjs.sql`DELETE FROM ${chunkOJHD3LXJ_cjs.sql.identifier(uniquesTableName)} WHERE ${chunkOJHD3LXJ_cjs.sql.identifier("graph_id")} = ${params.graphId} AND ${chunkOJHD3LXJ_cjs.sql.identifier("concrete_kind")} = ${params.concreteKind}`;
+}
+function buildCheckUnique(tables, params) {
+  const { uniques } = tables;
+  if (params.includeDeleted) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} = ${params.key}
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT * FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.nodeKind} = ${params.nodeKind}
+      AND ${uniques.constraintName} = ${params.constraintName}
+      AND ${uniques.key} = ${params.key}
+      AND ${uniques.deletedAt} IS NULL
+  `;
+}
+function buildCheckUniqueBatch(tables, params) {
+  const { uniques } = tables;
+  const keyPlaceholders = drizzleOrm.sql.join(
+    params.keys.map((key) => drizzleOrm.sql`${key}`),
+    drizzleOrm.sql`, `
+  );
+  if (params.includeDeleted) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${uniques}
+      WHERE ${uniques.graphId} = ${params.graphId}
+        AND ${uniques.nodeKind} = ${params.nodeKind}
+        AND ${uniques.constraintName} = ${params.constraintName}
+        AND ${uniques.key} IN (${keyPlaceholders})
+    `;
+  }
+  return drizzleOrm.sql`
+    SELECT * FROM ${uniques}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.nodeKind} = ${params.nodeKind}
+      AND ${uniques.constraintName} = ${params.constraintName}
+      AND ${uniques.key} IN (${keyPlaceholders})
+      AND ${uniques.deletedAt} IS NULL
+  `;
+}
+
+exports.POSTGRES_ROW_MAPPER_CONFIG = POSTGRES_ROW_MAPPER_CONFIG;
+exports.SQLITE_ROW_MAPPER_CONFIG = SQLITE_ROW_MAPPER_CONFIG;
+exports.buildCheckUnique = buildCheckUnique;
+exports.buildCheckUniqueBatch = buildCheckUniqueBatch;
+exports.buildDeleteUnique = buildDeleteUnique;
+exports.buildHardDeleteEdgeClaimsByEdgeKind = buildHardDeleteEdgeClaimsByEdgeKind;
+exports.buildHardDeleteEdgeClaimsByNodeKind = buildHardDeleteEdgeClaimsByNodeKind;
+exports.buildHardDeleteUniquesByConcreteKind = buildHardDeleteUniquesByConcreteKind;
+exports.buildHardDeleteUniquesByNode = buildHardDeleteUniquesByNode;
+exports.buildHardDeleteUniquesByNodeIds = buildHardDeleteUniquesByNodeIds;
+exports.buildInsertUnique = buildInsertUnique;
+exports.buildInsertUniqueBatch = buildInsertUniqueBatch;
+exports.buildLockEdgeClaims = buildLockEdgeClaims;
+exports.buildPurgeEdgeClaims = buildPurgeEdgeClaims;
+exports.buildTakeOverEdgeClaim = buildTakeOverEdgeClaim;
+exports.codePointOrderKey = codePointOrderKey;
+exports.coerceNumericScore = coerceNumericScore;
+exports.createEdgeRowMapper = createEdgeRowMapper;
+exports.createNodeRowMapper = createNodeRowMapper;
+exports.createSchemaVersionRowMapper = createSchemaVersionRowMapper;
+exports.createUniqueRowMapper = createUniqueRowMapper;
+exports.edgeColumnList = edgeColumnList;
+exports.edgePrimaryKeyConstraint = edgePrimaryKeyConstraint;
+exports.expectedValidFromPredicate = expectedValidFromPredicate;
+exports.formatPostgresTimestamp = formatPostgresTimestamp;
+exports.liveNodeIdsSubquery = liveNodeIdsSubquery;
+exports.nodeColumnList = nodeColumnList;
+exports.nodePrimaryKeyConstraint = nodePrimaryKeyConstraint;
+exports.normalizeRequiredRowTimestamp = normalizeRequiredRowTimestamp;
+exports.normalizeRowTimestamp = normalizeRowTimestamp;
+exports.nowIso = nowIso;
+exports.quotedColumn = quotedColumn;
+exports.quotedTableName = quotedTableName;
+exports.sqlNull = sqlNull;
+//# sourceMappingURL=chunk-EH3JZJUM.cjs.map
+//# sourceMappingURL=chunk-EH3JZJUM.cjs.map