@nicia-ai/typegraph 0.31.0 → 0.33.0

package/dist/chunk-PYD3UCDU.js

@@ -0,0 +1,1480 @@
+import { resolveFieldTypeInfoAtJsonPointer } from './chunk-XLUNB2TZ.js';
+import { UnsupportedPredicateError, CompilerInvariantError, DatabaseOperationError } from './chunk-TQOYM4LN.js';
+import { normalizeJsonPointer, joinJsonPointers, jsonPointer } from './chunk-K5P5OZXS.js';
+import { sql } from 'drizzle-orm';
+
+// src/query/subquery-utils.ts
+function normalizeValueType(valueType) {
+  if (valueType === void 0 || valueType === "unknown") {
+    return void 0;
+  }
+  return valueType;
+}
+function isUnsupportedInSubqueryValueType(valueType) {
+  const normalized = normalizeValueType(valueType);
+  return normalized === "array" || normalized === "object" || normalized === "embedding";
+}
+function isInSubqueryTypeCompatible(left, right) {
+  const normalizedLeft = normalizeValueType(left);
+  const normalizedRight = normalizeValueType(right);
+  if (normalizedLeft === void 0 || normalizedRight === void 0) {
+    return true;
+  }
+  return normalizedLeft === normalizedRight;
+}
+function getAggregateValueType(aggregate) {
+  switch (aggregate.function) {
+    case "count":
+    case "countDistinct":
+    case "sum":
+    case "avg": {
+      return "number";
+    }
+    case "min":
+    case "max": {
+      return normalizeValueType(aggregate.field.valueType);
+    }
+  }
+}
+function getProjectedValueTypes(subquery) {
+  if (subquery.selectiveFields && subquery.selectiveFields.length > 0) {
+    return subquery.selectiveFields.map(
+      (field) => normalizeValueType(field.valueType)
+    );
+  }
+  return subquery.projection.fields.map((field) => {
+    if (field.source.__type === "aggregate") {
+      return getAggregateValueType(field.source);
+    }
+    return normalizeValueType(field.source.valueType);
+  });
+}
+function getSubqueryColumnCount(subquery) {
+  return getProjectedValueTypes(subquery).length;
+}
+function getSingleSubqueryColumnValueType(subquery) {
+  const valueTypes = getProjectedValueTypes(subquery);
+  if (valueTypes.length !== 1) {
+    return void 0;
+  }
+  return valueTypes[0];
+}
+
+// src/query/predicates.ts
+function predicate(expr) {
+  return {
+    __expr: expr,
+    and: (other) => predicate({
+      __type: "and",
+      predicates: [expr, other.__expr]
+    }),
+    or: (other) => predicate({
+      __type: "or",
+      predicates: [expr, other.__expr]
+    }),
+    not: () => predicate({
+      __type: "not",
+      predicate: expr
+    })
+  };
+}
+function param(name) {
+  return { __type: "parameter", name };
+}
+function isParameterRef(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value.__type === "parameter";
+}
+function fieldRef(alias, path, options) {
+  return {
+    __type: "field_ref",
+    alias,
+    path,
+    ...options?.jsonPointer !== void 0 && {
+      jsonPointer: options.jsonPointer
+    },
+    ...options?.valueType !== void 0 && { valueType: options.valueType },
+    ...options?.elementType !== void 0 && {
+      elementType: options.elementType
+    }
+  };
+}
+function coerceLiteralValue(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(`Unsupported literal value type: ${typeof value}`);
+}
+function inferLiteralValueType(value) {
+  if (typeof value === "string") {
+    return "string";
+  }
+  if (typeof value === "number") {
+    return "number";
+  }
+  return "boolean";
+}
+function literal(value) {
+  if (value instanceof Date) {
+    return { __type: "literal", value: value.toISOString(), valueType: "date" };
+  }
+  const valueType = inferLiteralValueType(value);
+  return {
+    __type: "literal",
+    value,
+    valueType
+  };
+}
+function comparison(op, field, value) {
+  if (isParameterRef(value)) {
+    const expr2 = {
+      __type: "comparison",
+      op,
+      left: field,
+      right: value
+    };
+    return predicate(expr2);
+  }
+  const coercedValue = coerceLiteralValue(value);
+  const expr = {
+    __type: "comparison",
+    op,
+    left: field,
+    right: literal(coercedValue)
+  };
+  return predicate(expr);
+}
+function inComparison(op, field, values) {
+  const literals = values.map((value) => literal(coerceLiteralValue(value)));
+  const expr = {
+    __type: "comparison",
+    op,
+    left: field,
+    right: literals
+  };
+  return predicate(expr);
+}
+function stringOp(op, field, pattern) {
+  if (isParameterRef(pattern)) {
+    const expr2 = {
+      __type: "string_op",
+      op,
+      field,
+      pattern
+    };
+    return predicate(expr2);
+  }
+  const expr = {
+    __type: "string_op",
+    op,
+    field,
+    pattern
+  };
+  return predicate(expr);
+}
+function nullCheck(op, field) {
+  const expr = {
+    __type: "null_check",
+    op,
+    field
+  };
+  return predicate(expr);
+}
+function between(field, lower, upper) {
+  const expr = {
+    __type: "between",
+    field,
+    lower: isParameterRef(lower) ? lower : literal(lower),
+    upper: isParameterRef(upper) ? upper : literal(upper)
+  };
+  return predicate(expr);
+}
+function baseFieldBuilder(field) {
+  return {
+    eq: (value) => comparison("eq", field, value),
+    neq: (value) => comparison("neq", field, value),
+    isNull: () => nullCheck("isNull", field),
+    isNotNull: () => nullCheck("isNotNull", field),
+    in: (values) => inComparison("in", field, values),
+    notIn: (values) => inComparison("notIn", field, values)
+  };
+}
+function stringField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    contains: (pattern) => stringOp("contains", field, pattern),
+    startsWith: (pattern) => stringOp("startsWith", field, pattern),
+    endsWith: (pattern) => stringOp("endsWith", field, pattern),
+    like: (pattern) => stringOp("like", field, pattern),
+    ilike: (pattern) => stringOp("ilike", field, pattern)
+  };
+}
+var DEFAULT_FULLTEXT_MATCH_K = 50;
+function createFulltextAccessor(alias, hasSearchableField) {
+  return {
+    matches: (query, k, options) => {
+      if (!hasSearchableField()) {
+        throw new UnsupportedPredicateError(
+          `Cannot call .$fulltext.matches() on alias "${alias}" \u2014 its node kind has no fields declared with searchable(). Add at least one: \`title: searchable({ language: "english" })\`.`
+        );
+      }
+      return fulltextMatch(
+        fieldRef(alias, ["$fulltext"]),
+        query,
+        k ?? DEFAULT_FULLTEXT_MATCH_K,
+        options
+      );
+    }
+  };
+}
+function fulltextMatch(field, query, limit, options) {
+  if (!Number.isFinite(limit) || limit <= 0) {
+    throw new UnsupportedPredicateError(
+      `matches() limit must be a positive finite number, got ${String(limit)}`
+    );
+  }
+  const expr = {
+    __type: "fulltext_match",
+    field,
+    query,
+    mode: options?.mode ?? "websearch",
+    limit,
+    ...options?.language === void 0 ? {} : { language: options.language },
+    ...options?.minScore === void 0 ? {} : { minScore: options.minScore }
+  };
+  return predicate(expr);
+}
+function numberField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    between: (lower, upper) => between(field, lower, upper)
+  };
+}
+function dateField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    gt: (value) => comparison("gt", field, value),
+    gte: (value) => comparison("gte", field, value),
+    lt: (value) => comparison("lt", field, value),
+    lte: (value) => comparison("lte", field, value),
+    between: (lower, upper) => between(field, lower, upper)
+  };
+}
+function baseField(field) {
+  return baseFieldBuilder(field);
+}
+function arrayOp(op, field, values, length) {
+  const expr = {
+    __type: "array_op",
+    op,
+    field,
+    ...values !== void 0 && {
+      values: values.map((value) => literal(coerceLiteralValue(value)))
+    },
+    ...length !== void 0 && { length }
+  };
+  return predicate(expr);
+}
+function arrayField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    contains: (value) => arrayOp("contains", field, [value]),
+    containsAll: (values) => arrayOp("containsAll", field, values),
+    containsAny: (values) => arrayOp("containsAny", field, values),
+    isEmpty: () => arrayOp("isEmpty", field),
+    isNotEmpty: () => arrayOp("isNotEmpty", field),
+    lengthEq: (length) => arrayOp("lengthEq", field, void 0, length),
+    lengthGt: (length) => arrayOp("lengthGt", field, void 0, length),
+    lengthGte: (length) => arrayOp("lengthGte", field, void 0, length),
+    lengthLt: (length) => arrayOp("lengthLt", field, void 0, length),
+    lengthLte: (length) => arrayOp("lengthLte", field, void 0, length)
+  };
+}
+function vectorSimilarity(field, queryEmbedding, limit, options) {
+  const expr = {
+    __type: "vector_similarity",
+    field,
+    queryEmbedding,
+    // Leave metric unset when the caller didn't specify one, so the compiler
+    // resolves the field's declared metric per kind. Defaulting to "cosine"
+    // here would mis-rank l2/inner_product fields and bypass their ANN index.
+    ...options?.metric !== void 0 && { metric: options.metric },
+    limit,
+    ...options?.minScore !== void 0 && { minScore: options.minScore }
+  };
+  return predicate(expr);
+}
+function embeddingField(field) {
+  return {
+    ...baseFieldBuilder(field),
+    similarTo: (queryEmbedding, k, options) => vectorSimilarity(field, queryEmbedding, k, options)
+  };
+}
+function buildFieldBuilderForTypeInfo(field, typeInfo) {
+  if (!typeInfo) {
+    return baseField(field);
+  }
+  switch (typeInfo.valueType) {
+    case "string": {
+      return stringField(field);
+    }
+    case "number": {
+      return numberField(field);
+    }
+    case "boolean": {
+      return baseField(field);
+    }
+    case "date": {
+      return dateField(field);
+    }
+    case "array": {
+      return arrayField(field);
+    }
+    case "object": {
+      return objectField(field, { typeInfo });
+    }
+    case "embedding": {
+      return embeddingField(field);
+    }
+    case "unknown": {
+      return baseField(field);
+    }
+  }
+}
+function resolvePointerTypeInfo(typeInfo, pointer) {
+  return resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);
+}
+function objectOp(op, field, pointer, value, options) {
+  const expr = {
+    __type: "object_op",
+    op,
+    field,
+    pointer,
+    ...value !== void 0 && {
+      value: literal(coerceLiteralValue(value))
+    },
+    ...options?.valueType !== void 0 && { valueType: options.valueType },
+    ...options?.elementType !== void 0 && {
+      elementType: options.elementType
+    }
+  };
+  return predicate(expr);
+}
+function objectField(field, options) {
+  const basePointer = field.jsonPointer;
+  return {
+    ...baseFieldBuilder(field),
+    get: (key) => {
+      const pointer = jsonPointer([key]);
+      const nestedPointer = joinJsonPointers(basePointer, pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);
+      const nestedRef = fieldRef(field.alias, field.path, {
+        jsonPointer: nestedPointer,
+        ...resolved?.valueType !== void 0 && {
+          valueType: resolved.valueType
+        },
+        ...resolved?.elementType !== void 0 && {
+          elementType: resolved.elementType
+        }
+      });
+      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
+    },
+    hasKey: (key) => {
+      const pointer = jsonPointer([key]);
+      resolvePointerTypeInfo(options?.typeInfo, pointer);
+      return objectOp("hasKey", field, pointer);
+    },
+    hasPath: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      resolvePointerTypeInfo(options?.typeInfo, normalized);
+      return objectOp("hasPath", field, normalized);
+    },
+    pathEquals: (pointer, value) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      if (resolved && (resolved.valueType === "array" || resolved.valueType === "object")) {
+        throw new Error("pathEquals is only supported for scalar JSON values");
+      }
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp("pathEquals", field, normalized, value, predicateOptions);
+    },
+    pathContains: (pointer, value) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      if (resolved && resolved.valueType !== "array") {
+        throw new Error("pathContains is only supported for JSON array values");
+      }
+      const predicateOptions = resolved?.elementType === void 0 ? void 0 : { elementType: resolved.elementType };
+      return objectOp(
+        "pathContains",
+        field,
+        normalized,
+        value,
+        predicateOptions
+      );
+    },
+    pathIsNull: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp(
+        "pathIsNull",
+        field,
+        normalized,
+        void 0,
+        predicateOptions
+      );
+    },
+    pathIsNotNull: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
+      return objectOp(
+        "pathIsNotNull",
+        field,
+        normalized,
+        void 0,
+        predicateOptions
+      );
+    },
+    field: (pointer) => {
+      const normalized = normalizeJsonPointer(pointer);
+      const nestedPointer = joinJsonPointers(basePointer, normalized);
+      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
+      const nestedRef = fieldRef(field.alias, field.path, {
+        jsonPointer: nestedPointer,
+        ...resolved?.valueType !== void 0 && {
+          valueType: resolved.valueType
+        },
+        ...resolved?.elementType !== void 0 && {
+          elementType: resolved.elementType
+        }
+      });
+      return buildFieldBuilderForTypeInfo(nestedRef, resolved);
+    }
+  };
+}
+function exists(subquery) {
+  const expr = {
+    __type: "exists",
+    subquery,
+    negated: false
+  };
+  return predicate(expr);
+}
+function notExists(subquery) {
+  const expr = {
+    __type: "exists",
+    subquery,
+    negated: true
+  };
+  return predicate(expr);
+}
+function inSubquery(field, subquery) {
+  assertSingleColumnSubquery(subquery);
+  assertCompatibleSubqueryValueTypes(field, subquery);
+  const expr = {
+    __type: "in_subquery",
+    field,
+    subquery,
+    negated: false
+  };
+  return predicate(expr);
+}
+function notInSubquery(field, subquery) {
+  assertSingleColumnSubquery(subquery);
+  assertCompatibleSubqueryValueTypes(field, subquery);
+  const expr = {
+    __type: "in_subquery",
+    field,
+    subquery,
+    negated: true
+  };
+  return predicate(expr);
+}
+function assertSingleColumnSubquery(subquery) {
+  const columnCount = getSubqueryColumnCount(subquery);
+  if (columnCount === 1) return;
+  throw new UnsupportedPredicateError(
+    `IN/NOT IN subquery must project exactly 1 column, but got ${columnCount}`,
+    { subqueryColumnCount: columnCount },
+    {
+      suggestion: "Use aggregate() with exactly one projected field for scalar IN/NOT IN subqueries."
+    }
+  );
+}
+function assertCompatibleSubqueryValueTypes(field, subquery) {
+  const fieldValueType = field.valueType;
+  const subqueryValueType = getSingleSubqueryColumnValueType(subquery);
+  const resolvedValueType = fieldValueType ?? subqueryValueType;
+  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
+      { valueType: resolvedValueType },
+      {
+        suggestion: "Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates."
+      }
+    );
+  }
+  if (isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
+    return;
+  }
+  throw new UnsupportedPredicateError(
+    `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
+    {
+      fieldValueType,
+      subqueryValueType
+    }
+  );
+}
+
+// src/backend/types.ts
+function createBackendOverlay(target, overlay) {
+  const boundTargetMethods = /* @__PURE__ */ new Map();
+  function hasOverlayProperty(property) {
+    return Object.hasOwn(overlay, property);
+  }
+  function targetValue(targetObject, property) {
+    const value = Reflect.get(targetObject, property, targetObject);
+    if (typeof value !== "function") return value;
+    const cached = boundTargetMethods.get(property);
+    if (cached !== void 0) return cached;
+    const method = value;
+    const bound = method.bind(targetObject);
+    boundTargetMethods.set(property, bound);
+    return bound;
+  }
+  return new Proxy(target, {
+    get(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.get(overlay, property, overlay);
+      }
+      return targetValue(targetObject, property);
+    },
+    has(targetObject, property) {
+      return hasOverlayProperty(property) || Reflect.has(targetObject, property);
+    },
+    ownKeys(targetObject) {
+      return [
+        .../* @__PURE__ */ new Set([
+          ...Reflect.ownKeys(targetObject),
+          ...Reflect.ownKeys(overlay)
+        ])
+      ];
+    },
+    getOwnPropertyDescriptor(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(overlay, property);
+        if (descriptor === void 0) return;
+        return { ...descriptor, configurable: true };
+      }
+      return Reflect.getOwnPropertyDescriptor(targetObject, property);
+    },
+    set(targetObject, property, value) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.set(overlay, property, value, overlay);
+      }
+      return Reflect.set(targetObject, property, value, targetObject);
+    },
+    defineProperty(targetObject, property, attributes) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.defineProperty(overlay, property, attributes);
+      }
+      return Reflect.defineProperty(targetObject, property, attributes);
+    },
+    deleteProperty(targetObject, property) {
+      if (hasOverlayProperty(property)) {
+        return Reflect.deleteProperty(overlay, property);
+      }
+      return Reflect.deleteProperty(targetObject, property);
+    }
+  });
+}
+function wrapWithManagedClose(backend, teardown) {
+  let isClosed = false;
+  return createBackendOverlay(backend, {
+    async close() {
+      if (isClosed) return;
+      isClosed = true;
+      await backend.close();
+      await teardown();
+    }
+  });
+}
+async function runOptionallyInTransaction(backend, fn, fallback) {
+  if ("transaction" in backend && backend.capabilities.transactions) {
+    return backend.transaction((tx) => fn(tx));
+  }
+  return fn(fallback ?? backend);
+}
+var SQLITE_MAX_BIND_PARAMETERS = 999;
+var POSTGRES_MAX_BIND_PARAMETERS = 65535;
+var SQLITE_CAPABILITIES = {
+  transactions: true,
+  // SQLite supports transactions
+  windowFunctions: true,
+  // SQLite has supported window functions since 3.25.0
+  returning: true,
+  // SQLite has supported RETURNING since 3.35.0
+  maxBindParameters: SQLITE_MAX_BIND_PARAMETERS
+};
+var POSTGRES_CAPABILITIES = {
+  transactions: true,
+  // PostgreSQL supports transactions
+  windowFunctions: true,
+  // PostgreSQL supports ROW_NUMBER() and related windows
+  returning: true,
+  // PostgreSQL has supported RETURNING since 8.2
+  maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS
+};
+var COMPARISON_OP_SQL = {
+  eq: "=",
+  neq: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+function compileFieldColumn(field, cteAlias, cteColumnPrefix) {
+  if (cteColumnPrefix !== void 0) {
+    const qualifier2 = cteColumnPrefix === "" ? "" : `${cteColumnPrefix}.`;
+    if (field.path.length === 1 && field.path[0] === "id") {
+      return sql.raw(`${qualifier2}id`);
+    }
+    if (field.path.length === 1 && field.path[0] === "kind") {
+      return sql.raw(`${qualifier2}kind`);
+    }
+    if (field.path.length > 0 && field.path[0] === "props") {
+      return sql.raw(`${qualifier2}props`);
+    }
+    return sql.raw(`${qualifier2}${field.path.join("_")}`);
+  }
+  const prefix = field.alias;
+  const qualifier = cteAlias ? `${cteAlias}.` : "";
+  if (field.path.length === 1 && field.path[0] === "id") {
+    return sql.raw(`${qualifier}${prefix}_id`);
+  }
+  if (field.path.length === 1 && field.path[0] === "kind") {
+    return sql.raw(`${qualifier}${prefix}_kind`);
+  }
+  if (field.path.length > 0 && field.path[0] === "props") {
+    return sql.raw(`${qualifier}${prefix}_props`);
+  }
+  return sql.raw(`${qualifier}${prefix}_${field.path.join("_")}`);
+}
+function getFieldPointer(field) {
+  if (field.jsonPointer !== void 0) {
+    return field.jsonPointer;
+  }
+  if (field.path.length > 1 && field.path[0] === "props") {
+    return jsonPointer(field.path.slice(1));
+  }
+  return void 0;
+}
+function isJsonField(field) {
+  return field.path.length > 0 && field.path[0] === "props";
+}
+function normalizeValueType2(valueType) {
+  if (!valueType || valueType === "unknown") {
+    return void 0;
+  }
+  return valueType;
+}
+function compileFieldValue(field, dialect, valueType, cteAlias, pointerOverride, cteColumnPrefix) {
+  const resolved = normalizeValueType2(valueType);
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = pointerOverride ?? getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  switch (resolved) {
+    case "number": {
+      return dialect.jsonExtractNumber(column, pointer);
+    }
+    case "boolean": {
+      return dialect.jsonExtractBoolean(column, pointer);
+    }
+    case "date": {
+      return dialect.jsonExtractDate(column, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return dialect.jsonExtract(column, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return dialect.jsonExtractText(column, pointer);
+    }
+  }
+}
+function compileFieldTextValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  return dialect.jsonExtractText(column, pointer);
+}
+function compileFieldJsonValue(field, dialect, cteAlias, pointerOverride, cteColumnPrefix) {
+  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);
+  if (!isJsonField(field)) {
+    return column;
+  }
+  const pointer = pointerOverride ?? getFieldPointer(field);
+  if (!pointer || pointer === "") {
+    return column;
+  }
+  return dialect.jsonExtract(column, pointer);
+}
+function resolveLiteralValueTypes(literals) {
+  const resolved = /* @__PURE__ */ new Set();
+  for (const literal2 of literals) {
+    const valueType = normalizeValueType2(literal2.valueType);
+    if (valueType) {
+      resolved.add(valueType);
+    }
+  }
+  if (resolved.size > 1) {
+    throw new UnsupportedPredicateError(
+      "Mixed literal value types are not supported in predicates",
+      { valueTypes: [...resolved] }
+    );
+  }
+  return resolved.values().next().value;
+}
+function resolveComparisonValueType(field, right) {
+  if (isParameterRef(right)) {
+    return normalizeValueType2(right.valueType) ?? normalizeValueType2(field.valueType);
+  }
+  const literals = Array.isArray(right) ? right : [right];
+  const literalType = resolveLiteralValueTypes(literals);
+  const fieldType = normalizeValueType2(field.valueType);
+  if (fieldType === "date" && literalType === "string") {
+    return fieldType;
+  }
+  if (literalType) {
+    return literalType;
+  }
+  return fieldType;
+}
+function resolvePredicateValueType(preferred, literal2) {
+  const normalizedPreferred = normalizeValueType2(preferred);
+  if (normalizedPreferred) {
+    return normalizedPreferred;
+  }
+  return literal2 ? normalizeValueType2(literal2.valueType) : void 0;
+}
+function convertValueForSql(value, dialect) {
+  return dialect.bindValue(value);
+}
+function compileStringPattern(op, pattern) {
+  const escaped = pattern.replaceAll("%", String.raw`\%`).replaceAll("_", String.raw`\_`);
+  switch (op) {
+    case "contains": {
+      return `%${escaped}%`;
+    }
+    case "startsWith": {
+      return `${escaped}%`;
+    }
+    case "endsWith": {
+      return `%${escaped}`;
+    }
+    case "like":
+    case "ilike": {
+      return pattern;
+    }
+    default: {
+      return escaped;
+    }
+  }
+}
+function escapeLikePatternParameter(parameter) {
+  return sql`REPLACE(REPLACE(REPLACE(${parameter}, '\\', '\\\\'), '%', '\\%'), '_', '\\_')`;
+}
+function compileParameterizedStringPattern(op, parameter) {
+  switch (op) {
+    case "contains": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`'%' || ${escaped} || '%'`;
+    }
+    case "startsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`${escaped} || '%'`;
+    }
+    case "endsWith": {
+      const escaped = escapeLikePatternParameter(parameter);
+      return sql`'%' || ${escaped}`;
+    }
+    case "like":
+    case "ilike": {
+      return parameter;
+    }
+    default: {
+      return escapeLikePatternParameter(parameter);
+    }
+  }
+}
+function compilePredicateExpression(expr, ctx) {
+  const { dialect } = ctx;
+  const cteColumnPrefix = ctx.cteColumnPrefix;
+  switch (expr.__type) {
+    case "comparison": {
+      return compileComparisonPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "string_op": {
+      const field = compileFieldTextValue(
+        expr.field,
+        dialect,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      if (isParameterRef(expr.pattern)) {
+        const placeholder = sql`${sql.placeholder(expr.pattern.name)}`;
+        const pattern2 = compileParameterizedStringPattern(expr.op, placeholder);
+        if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
+          return dialect.ilike(field, pattern2);
+        }
+        return sql`${field} LIKE ${pattern2}`;
+      }
+      const pattern = compileStringPattern(expr.op, expr.pattern);
+      if (expr.op === "ilike" || expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") {
+        return dialect.ilike(field, pattern);
+      }
+      return sql`${field} LIKE ${pattern}`;
+    }
+    case "null_check": {
+      const field = compileFieldTextValue(
+        expr.field,
+        dialect,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      return expr.op === "isNull" ? sql`${field} IS NULL` : sql`${field} IS NOT NULL`;
+    }
+    case "between": {
+      const lowerIsParam = isParameterRef(expr.lower);
+      const upperIsParam = isParameterRef(expr.upper);
+      const boundsForType = [];
+      if (!lowerIsParam) boundsForType.push(expr.lower);
+      if (!upperIsParam) boundsForType.push(expr.upper);
+      const valueType = boundsForType.length > 0 ? resolveComparisonValueType(expr.field, boundsForType) : normalizeValueType2(expr.field.valueType);
+      if (valueType === "array" || valueType === "object") {
+        throw new UnsupportedPredicateError(
+          "Between comparisons are not supported for JSON arrays or objects"
+        );
+      }
+      const field = compileFieldValue(
+        expr.field,
+        dialect,
+        valueType,
+        void 0,
+        void 0,
+        cteColumnPrefix
+      );
+      const lower = lowerIsParam ? sql.placeholder(expr.lower.name) : convertValueForSql(expr.lower.value, dialect);
+      const upper = upperIsParam ? sql.placeholder(expr.upper.name) : convertValueForSql(expr.upper.value, dialect);
+      return sql`${field} BETWEEN ${lower} AND ${upper}`;
+    }
+    case "and": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return sql`(${sql.join(parts, sql` AND `)})`;
+    }
+    case "or": {
+      const parts = expr.predicates.map(
+        (p) => compilePredicateExpression(p, ctx)
+      );
+      return sql`(${sql.join(parts, sql` OR `)})`;
+    }
+    case "not": {
+      const inner = compilePredicateExpression(expr.predicate, ctx);
+      return sql`NOT (${inner})`;
+    }
+    case "array_op": {
+      return compileArrayPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "object_op": {
+      return compileObjectPredicate(expr, dialect, cteColumnPrefix);
+    }
+    case "aggregate_comparison": {
+      return compileAggregatePredicate(expr, dialect);
+    }
+    case "exists": {
+      return compileExistsSubquery(expr, ctx);
+    }
+    case "in_subquery": {
+      return compileInSubquery(expr, ctx);
+    }
+    case "vector_similarity":
+    case "fulltext_match": {
+      return STRUCTURAL_PREDICATE_NOOP;
+    }
+  }
+}
+var STRUCTURAL_PREDICATE_NOOP = sql.raw("1=1");
+function compileComparisonPredicate(expr, dialect, cteColumnPrefix) {
+  if (isParameterRef(expr.right)) {
+    const parameterValueType = normalizeValueType2(expr.right.valueType) ?? normalizeValueType2(expr.left.valueType);
+    const left2 = compileFieldValue(
+      expr.left,
+      dialect,
+      parameterValueType,
+      void 0,
+      void 0,
+      cteColumnPrefix
+    );
+    const opSql2 = COMPARISON_OP_SQL[expr.op];
+    if (!opSql2) {
+      throw new UnsupportedPredicateError(
+        `Comparison operation "${expr.op}" is not supported for parameterized predicates`
+      );
+    }
+    return sql`${left2} ${sql.raw(opSql2)} ${sql.placeholder(expr.right.name)}`;
+  }
+  const valueType = resolveComparisonValueType(expr.left, expr.right);
+  if (valueType === "array" || valueType === "object") {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported for ${valueType} values`
+    );
+  }
+  const left = compileFieldValue(
+    expr.left,
+    dialect,
+    valueType,
+    void 0,
+    void 0,
+    cteColumnPrefix
+  );
+  if (expr.op === "in" || expr.op === "notIn") {
+    const values = Array.isArray(expr.right) ? expr.right : [expr.right];
+    if (values.length === 0) {
+      return expr.op === "in" ? sql.raw("1=0") : sql.raw("1=1");
+    }
+    const placeholders = values.map(
+      (v) => sql`${convertValueForSql(v.value, dialect)}`
+    );
+    const op = expr.op === "in" ? sql.raw("IN") : sql.raw("NOT IN");
+    return sql`${left} ${op} (${sql.join(placeholders, sql`, `)})`;
+  }
+  const right = expr.right;
+  const rightValue = Array.isArray(right) ? right[0] : right;
+  const convertedRight = convertValueForSql(rightValue.value, dialect);
+  const opSql = COMPARISON_OP_SQL[expr.op];
+  if (!opSql) {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported`
+    );
+  }
+  return sql`${left} ${sql.raw(opSql)} ${convertedRight}`;
+}
+function compileArrayPredicate(expr, dialect, cteColumnPrefix) {
+  const field = compileFieldJsonValue(
+    expr.field,
+    dialect,
+    void 0,
+    void 0,
+    cteColumnPrefix
+  );
+  const values = expr.values?.map((v) => convertValueForSql(v.value, dialect)) ?? [];
+  switch (expr.op) {
+    case "isEmpty": {
+      return sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;
+    }
+    case "isNotEmpty": {
+      return sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;
+    }
+    case "lengthEq": {
+      return sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;
+    }
+    case "lengthGt": {
+      return sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;
+    }
+    case "lengthGte": {
+      return sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;
+    }
+    case "lengthLt": {
+      return sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;
+    }
+    case "lengthLte": {
+      return sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;
+    }
+    case "contains": {
+      const value = values[0];
+      if (value === void 0) {
+        return sql.raw("1=0");
+      }
+      return dialect.jsonArrayContains(field, value);
+    }
+    case "containsAll": {
+      return dialect.jsonArrayContainsAll(field, values);
+    }
+    case "containsAny": {
+      return dialect.jsonArrayContainsAny(field, values);
+    }
+  }
+}
+function compileObjectPredicate(expr, dialect, cteColumnPrefix) {
+  const basePointer = getFieldPointer(expr.field);
+  const pointer = joinJsonPointers(basePointer, expr.pointer);
+  const column = compileFieldColumn(expr.field, void 0, cteColumnPrefix);
+  switch (expr.op) {
+    case "hasKey":
+    case "hasPath": {
+      return dialect.jsonHasPath(column, pointer);
+    }
+    case "pathEquals": {
+      if (!expr.value) {
+        throw new UnsupportedPredicateError(
+          "pathEquals requires a comparison value"
+        );
+      }
+      const valueType = resolvePredicateValueType(expr.valueType, expr.value);
+      if (valueType === "array" || valueType === "object") {
+        throw new UnsupportedPredicateError(
+          "pathEquals is not supported for JSON arrays or objects"
+        );
+      }
+      const left = compileFieldValue(
+        expr.field,
+        dialect,
+        valueType,
+        void 0,
+        pointer,
+        cteColumnPrefix
+      );
+      return sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;
+    }
+    case "pathContains": {
+      if (!expr.value) {
+        throw new UnsupportedPredicateError(
+          "pathContains requires a comparison value"
+        );
+      }
+      const arrayField2 = compileFieldJsonValue(
+        expr.field,
+        dialect,
+        void 0,
+        pointer,
+        cteColumnPrefix
+      );
+      return dialect.jsonArrayContains(
+        arrayField2,
+        convertValueForSql(expr.value.value, dialect)
+      );
+    }
+    case "pathIsNull": {
+      return dialect.jsonPathIsNull(column, pointer);
+    }
+    case "pathIsNotNull": {
+      return dialect.jsonPathIsNotNull(column, pointer);
+    }
+  }
+}
+function compileAggregatePredicate(expr, dialect) {
+  const aggregate = compileAggregateExpr(expr.aggregate, dialect);
+  const op = COMPARISON_OP_SQL[expr.op];
+  if (!op) {
+    throw new UnsupportedPredicateError(
+      `Comparison operation "${expr.op}" is not supported for aggregate predicates`
+    );
+  }
+  const convertedValue = convertValueForSql(expr.value.value, dialect);
+  return sql`${aggregate} ${sql.raw(op)} ${convertedValue}`;
+}
+function compileAggregateExpr(expr, dialect) {
+  const cteAlias = `cte_${expr.field.alias}`;
+  const field = compileFieldValue(
+    expr.field,
+    dialect,
+    expr.field.valueType,
+    cteAlias
+  );
+  switch (expr.function) {
+    case "count": {
+      return sql`COUNT(${field})`;
+    }
+    case "countDistinct": {
+      return sql`COUNT(DISTINCT ${field})`;
+    }
+    case "sum": {
+      return sql`SUM(${field})`;
+    }
+    case "avg": {
+      return sql`AVG(${field})`;
+    }
+    case "min": {
+      return sql`MIN(${field})`;
+    }
+    case "max": {
+      return sql`MAX(${field})`;
+    }
+    default: {
+      throw new UnsupportedPredicateError(
+        `Unknown aggregate function: ${expr.function}`
+      );
+    }
+  }
+}
+function compileExistsSubquery(expr, ctx) {
+  if (expr.subquery.graphId === void 0) {
+    throw new UnsupportedPredicateError("EXISTS subquery must have a graphId");
+  }
+  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
+  return expr.negated ? sql`NOT EXISTS (${subSql})` : sql`EXISTS (${subSql})`;
+}
+function compileInSubquery(expr, ctx) {
+  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);
+  if (subqueryColumnCount !== 1) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery must project exactly 1 column, but got ${subqueryColumnCount}`,
+      { subqueryColumnCount }
+    );
+  }
+  const fieldValueType = normalizeValueType2(expr.field.valueType);
+  const subqueryValueType = getSingleSubqueryColumnValueType(expr.subquery);
+  const resolvedValueType = fieldValueType ?? subqueryValueType;
+  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,
+      { valueType: resolvedValueType }
+    );
+  }
+  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {
+    throw new UnsupportedPredicateError(
+      `IN/NOT IN type mismatch: field type "${String(fieldValueType)}" does not match subquery column type "${String(subqueryValueType)}"`,
+      {
+        fieldValueType,
+        subqueryValueType
+      }
+    );
+  }
+  const valueType = fieldValueType ?? subqueryValueType;
+  if (expr.subquery.graphId === void 0) {
+    throw new UnsupportedPredicateError(
+      "IN/NOT IN subquery must have a graphId"
+    );
+  }
+  const fieldSql = compileFieldValue(
+    expr.field,
+    ctx.dialect,
+    valueType,
+    void 0,
+    void 0,
+    ctx.cteColumnPrefix
+  );
+  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
+  return expr.negated ? sql`${fieldSql} NOT IN (${subSql})` : sql`${fieldSql} IN (${subSql})`;
+}
+function extractStructuralPredicates(predicates, isMatch, rejectionMessage) {
+  const results = [];
+  function visit(expr, inDisallowedBranch) {
+    if (isMatch(expr)) {
+      if (inDisallowedBranch) {
+        throw new UnsupportedPredicateError(rejectionMessage);
+      }
+      results.push(expr);
+      return;
+    }
+    switch (expr.__type) {
+      case "and": {
+        for (const child of expr.predicates) visit(child, inDisallowedBranch);
+        return;
+      }
+      case "or": {
+        for (const child of expr.predicates) visit(child, true);
+        return;
+      }
+      case "not": {
+        visit(expr.predicate, true);
+        return;
+      }
+      case "comparison":
+      case "string_op":
+      case "null_check":
+      case "between":
+      case "array_op":
+      case "object_op":
+      case "aggregate_comparison":
+      case "exists":
+      case "in_subquery":
+      case "vector_similarity":
+      case "fulltext_match": {
+        return;
+      }
+    }
+  }
+  for (const pred of predicates) visit(pred.expression, false);
+  return results;
+}
+function extractVectorSimilarityPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "vector_similarity",
+    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
+function extractFulltextMatchPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "fulltext_match",
+    "Fulltext match predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
+var EMPTY_PREDICATES = [];
+function sqlValueList(values) {
+  return sql.join(
+    values.map((value) => sql`${value}`),
+    sql`, `
+  );
+}
+function buildPredicateIndexKey(alias, targetType) {
+  return `${alias}\0${targetType}`;
+}
+function resolvePredicateTargetType(predicate2) {
+  return predicate2.targetType === "edge" ? "edge" : "node";
+}
+function buildPredicateIndex(ast) {
+  const byAliasAndType = /* @__PURE__ */ new Map();
+  for (const predicate2 of ast.predicates) {
+    const key = buildPredicateIndexKey(
+      predicate2.targetAlias,
+      resolvePredicateTargetType(predicate2)
+    );
+    const existing = byAliasAndType.get(key);
+    if (existing === void 0) {
+      byAliasAndType.set(key, [predicate2]);
+    } else {
+      existing.push(predicate2);
+    }
+  }
+  return { byAliasAndType };
+}
+function getPredicatesForAlias(predicateIndex, alias, targetType) {
+  return predicateIndex.byAliasAndType.get(
+    buildPredicateIndexKey(alias, targetType)
+  ) ?? EMPTY_PREDICATES;
+}
+function compilePredicateClauses(predicates, predicateContext) {
+  return predicates.map(
+    (predicate2) => compilePredicateExpression(predicate2.expression, predicateContext)
+  );
+}
+function compileKindFilter(column, kinds) {
+  if (kinds.length === 0) {
+    return sql`1 = 0`;
+  }
+  if (kinds.length === 1) {
+    return sql`${column} = ${kinds[0]}`;
+  }
+  return sql`${column} IN (${sqlValueList(kinds)})`;
+}
+function getNodeKindsForAlias(ast, alias) {
+  if (alias === ast.start.alias) {
+    return ast.start.kinds;
+  }
+  for (const traversal of ast.traversals) {
+    if (traversal.nodeAlias === alias) {
+      return traversal.nodeKinds;
+    }
+  }
+  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
+}
+function getHybridTargetAlias(vectorPredicate, fulltextPredicate) {
+  if (!vectorPredicate || !fulltextPredicate) return void 0;
+  return vectorPredicate.field.alias === fulltextPredicate.field.alias ? vectorPredicate.field.alias : void 0;
+}
+
+// src/backend/drizzle/row-mappers.ts
+function requireTimestamp(value, field) {
+  if (value === void 0) {
+    throw new DatabaseOperationError(
+      `Expected non-null ${field} timestamp`,
+      { operation: "select", entity: "row" }
+    );
+  }
+  return value;
+}
+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 nullToUndefined(value) {
+  return value ?? void 0;
+}
+function formatPostgresTimestamp(value) {
+  if (value === null || value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") {
+    if (value.includes("T")) return value;
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+    return value;
+  }
+  return void 0;
+}
+function 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) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? {});
+}
+var SQLITE_ROW_MAPPER_CONFIG = {
+  formatTimestamp: (value) => {
+    if (value === null || value === void 0) return;
+    if (typeof value !== "string") {
+      throw new DatabaseOperationError(
+        `Expected timestamp to be string, got ${typeof value}`,
+        { operation: "select", entity: "row" }
+      );
+    }
+    return value;
+  },
+  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 = {
+  formatTimestamp: formatPostgresTimestamp,
+  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: nullToUndefined(config.formatTimestamp(row.valid_from)),
+    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
+    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
+    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createEdgeRowMapper(config) {
+  return (row) => ({
+    graph_id: 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: nullToUndefined(config.formatTimestamp(row.valid_from)),
+    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
+    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
+    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createUniqueRowMapper(config) {
+  return (row) => ({
+    graph_id: 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: nullToUndefined(config.formatTimestamp(row.deleted_at))
+  });
+}
+function createSchemaVersionRowMapper(config) {
+  return (row) => {
+    const isActiveValue = row.is_active;
+    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
+    return {
+      graph_id: asString(row.graph_id, "graph_id"),
+      version: asNumber(row.version, "version"),
+      schema_hash: asString(row.schema_hash, "schema_hash"),
+      schema_doc: config.normalizeJson(row.schema_doc),
+      created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
+      is_active: isActive
+    };
+  };
+}
+
+// src/utils/array.ts
+function chunk(items, size) {
+  if (!Number.isSafeInteger(size) || size < 1) {
+    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);
+  }
+  if (items.length === 0) return [];
+  if (items.length <= size) return [items];
+  const chunks = [];
+  for (let start = 0; start < items.length; start += size) {
+    chunks.push(items.slice(start, start + size));
+  }
+  return chunks;
+}
+function groupBy(items, keyFor) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFor(item);
+    const group = groups.get(key) ?? [];
+    group.push(item);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
+// src/utils/presence.ts
+function isPresent(value) {
+  return value !== null && value !== void 0;
+}
+
+export { POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, SQLITE_ROW_MAPPER_CONFIG, arrayField, baseField, buildFieldBuilderForTypeInfo, buildPredicateIndex, chunk, coerceNumericScore, compileFieldValue, compileKindFilter, compilePredicateClauses, compilePredicateExpression, createBackendOverlay, createEdgeRowMapper, createFulltextAccessor, createNodeRowMapper, createSchemaVersionRowMapper, createUniqueRowMapper, dateField, exists, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, fieldRef, formatPostgresTimestamp, getHybridTargetAlias, getNodeKindsForAlias, getPredicatesForAlias, groupBy, inSubquery, isParameterRef, isPresent, notExists, notInSubquery, nowIso, numberField, objectField, param, runOptionallyInTransaction, sqlValueList, stringField, wrapWithManagedClose };
+//# sourceMappingURL=chunk-PYD3UCDU.js.map
+//# sourceMappingURL=chunk-PYD3UCDU.js.map