@nicia-ai/typegraph 0.29.0 → 0.31.0

package/dist/{chunk-C2RWFIYP.cjs → chunk-V4IQYOQ4.cjs}

@@ -1,10 +1,7 @@
 'use strict';
 
-var chunk7V335GHG_cjs = require('./chunk-7V335GHG.cjs');
+var chunkFLRCVI2G_cjs = require('./chunk-FLRCVI2G.cjs');
 var drizzleOrm = require('drizzle-orm');
-var casing = require('drizzle-orm/casing');
-var pgCore = require('drizzle-orm/pg-core');
-var sqliteCore = require('drizzle-orm/sqlite-core');
 
 function sqlNull(value) {
   return value ?? drizzleOrm.sql.raw("NULL");
@@ -384,6 +381,97 @@ var fts5Strategy = {
     return stmt === void 0 ? [] : [stmt];
   }
 };
+var VECTOR_CONTRIBUTION_PREFIX = "vector";
+function buildVectorCapabilities(strategy) {
+  return strategy.capabilities;
+}
+function vectorScoreExpression(distanceExpression, metric) {
+  switch (metric) {
+    case "cosine": {
+      return drizzleOrm.sql`(1 - (${distanceExpression}))`;
+    }
+    case "l2":
+    case "inner_product": {
+      return distanceExpression;
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+function vectorMinScoreCondition(distanceExpression, metric, minScore) {
+  assertVectorMinScore(minScore, metric);
+  switch (metric) {
+    case "cosine": {
+      return drizzleOrm.sql`${distanceExpression} <= ${1 - minScore}`;
+    }
+    case "l2": {
+      return drizzleOrm.sql`${distanceExpression} <= ${minScore}`;
+    }
+    case "inner_product": {
+      return drizzleOrm.sql`${distanceExpression} <= ${-minScore}`;
+    }
+    default: {
+      const _exhaustive = metric;
+      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
+    }
+  }
+}
+function assertFiniteEmbedding(embedding, name) {
+  for (const [index, value] of embedding.entries()) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new TypeError(
+        `${name}[${index}] must be a finite number, got: ${value}`
+      );
+    }
+  }
+}
+function assertVectorSearchLimit(limit) {
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new RangeError(
+      `vectorSearch limit must be a positive integer, got: ${limit}`
+    );
+  }
+}
+function assertVectorMinScore(minScore, metric, label = "minScore") {
+  if (!Number.isFinite(minScore)) {
+    throw new RangeError(`${label} must be a finite number, got: ${minScore}`);
+  }
+  if (metric === "cosine" && (minScore < -1 || minScore > 1)) {
+    throw new RangeError(
+      `${label} for the cosine metric must be between -1 and 1, got: ${minScore}`
+    );
+  }
+}
+var MAX_VECTOR_IDENTIFIER_LENGTH = 63;
+function sanitizeIdentifierPart(value) {
+  return value.toLowerCase().replaceAll(/[^a-z0-9_]/g, "_");
+}
+function shortHash(input) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let index = 0; index < input.length; index++) {
+    const ch = input.codePointAt(index);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hi = (h2 >>> 0).toString(16).padStart(8, "0");
+  const lo = (h1 >>> 0).toString(16).padStart(8, "0");
+  return `${hi}${lo}`.slice(0, 8);
+}
+function vectorPhysicalName(prefix, graphId, nodeKind, fieldPath) {
+  const readable = `${prefix}_${sanitizeIdentifierPart(graphId)}_${sanitizeIdentifierPart(nodeKind)}_${sanitizeIdentifierPart(fieldPath)}`;
+  const hash = shortHash(JSON.stringify([graphId, nodeKind, fieldPath]));
+  const full = `${readable}_${hash}`;
+  if (full.length <= MAX_VECTOR_IDENTIFIER_LENGTH) return full;
+  return `${readable.slice(0, MAX_VECTOR_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;
+}
+function quoteIdentifier2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
 function escapePostgresLiteral(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
@@ -391,7 +479,7 @@ function toPostgresPath(pointer) {
   if (!pointer || pointer === "" || pointer === "/") {
     return drizzleOrm.sql.raw("ARRAY[]::text[]");
   }
-  const segments = chunk7V335GHG_cjs.parseJsonPointer(pointer);
+  const segments = chunkFLRCVI2G_cjs.parseJsonPointer(pointer);
   if (segments.length === 0) {
     return drizzleOrm.sql.raw("ARRAY[]::text[]");
   }
@@ -479,6 +567,12 @@ var postgresDialect = {
     return drizzleOrm.sql`(${column} #> ${path} IS NOT NULL AND ${column} #>> ${path} != 'null')`;
   },
   // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return drizzleOrm.sql`${left} IS NOT DISTINCT FROM ${right}`;
+  },
+  // ============================================================
   // String Operations
   // ============================================================
   ilike(column, pattern) {
@@ -541,7 +635,7 @@ function toSqlitePath(pointer) {
   if (!pointer || pointer === "" || pointer === "/") {
     return "$";
   }
-  const segments = chunk7V335GHG_cjs.parseJsonPointer(pointer);
+  const segments = chunkFLRCVI2G_cjs.parseJsonPointer(pointer);
   const parts = ["$"];
   for (const segment of segments) {
     if (isArrayIndex(segment)) {
@@ -638,6 +732,12 @@ var sqliteDialect = {
     return drizzleOrm.sql`(json_extract(${column}, ${pathSql}) IS NOT NULL AND json_type(${column}, ${pathSql}) != 'null')`;
   },
   // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return drizzleOrm.sql`${left} IS ${right}`;
+  },
+  // ============================================================
   // String Operations
   // ============================================================
   ilike(column, pattern) {
@@ -696,97 +796,6 @@ var sqliteDialect = {
   // ============================================================
   fulltext: fts5Strategy
 };
-var VECTOR_CONTRIBUTION_PREFIX = "vector";
-function buildVectorCapabilities(strategy) {
-  return strategy.capabilities;
-}
-function vectorScoreExpression(distanceExpression, metric) {
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`(1 - (${distanceExpression}))`;
-    }
-    case "l2":
-    case "inner_product": {
-      return distanceExpression;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function vectorMinScoreCondition(distanceExpression, metric, minScore) {
-  assertVectorMinScore(minScore, metric);
-  switch (metric) {
-    case "cosine": {
-      return drizzleOrm.sql`${distanceExpression} <= ${1 - minScore}`;
-    }
-    case "l2": {
-      return drizzleOrm.sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      return drizzleOrm.sql`${distanceExpression} <= ${-minScore}`;
-    }
-    default: {
-      const _exhaustive = metric;
-      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);
-    }
-  }
-}
-function assertFiniteEmbedding(embedding, name) {
-  for (const [index, value] of embedding.entries()) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new TypeError(
-        `${name}[${index}] must be a finite number, got: ${value}`
-      );
-    }
-  }
-}
-function assertVectorSearchLimit(limit) {
-  if (!Number.isInteger(limit) || limit <= 0) {
-    throw new RangeError(
-      `vectorSearch limit must be a positive integer, got: ${limit}`
-    );
-  }
-}
-function assertVectorMinScore(minScore, metric, label = "minScore") {
-  if (!Number.isFinite(minScore)) {
-    throw new RangeError(`${label} must be a finite number, got: ${minScore}`);
-  }
-  if (metric === "cosine" && (minScore < -1 || minScore > 1)) {
-    throw new RangeError(
-      `${label} for the cosine metric must be between -1 and 1, got: ${minScore}`
-    );
-  }
-}
-var MAX_VECTOR_IDENTIFIER_LENGTH = 63;
-function sanitizeIdentifierPart(value) {
-  return value.toLowerCase().replaceAll(/[^a-z0-9_]/g, "_");
-}
-function shortHash(input) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let index = 0; index < input.length; index++) {
-    const ch = input.codePointAt(index);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  const hi = (h2 >>> 0).toString(16).padStart(8, "0");
-  const lo = (h1 >>> 0).toString(16).padStart(8, "0");
-  return `${hi}${lo}`.slice(0, 8);
-}
-function vectorPhysicalName(prefix, graphId, nodeKind, fieldPath) {
-  const readable = `${prefix}_${sanitizeIdentifierPart(graphId)}_${sanitizeIdentifierPart(nodeKind)}_${sanitizeIdentifierPart(fieldPath)}`;
-  const hash = shortHash(JSON.stringify([graphId, nodeKind, fieldPath]));
-  const full = `${readable}_${hash}`;
-  if (full.length <= MAX_VECTOR_IDENTIFIER_LENGTH) return full;
-  return `${readable.slice(0, MAX_VECTOR_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;
-}
-function quoteIdentifier2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
 
 // src/query/dialect/index.ts
 var DIALECT_ADAPTERS = {
@@ -842,6 +851,20 @@ function compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn) {
   }
   return { keys };
 }
+function compileNodeIndexFieldKeys(index, ctx) {
+  const adapter = getDialect(ctx.dialect);
+  const keys = [];
+  for (const [position, pointer] of index.fields.entries()) {
+    const extracted = compileIndexKeyValue(
+      adapter,
+      ctx.propsColumn,
+      pointer,
+      index.fieldValueTypes[position]
+    );
+    keys.push(drizzleOrm.sql`(${extracted})`);
+  }
+  return keys;
+}
 function compileIndexKeyValue(dialect, propsColumn, pointer, valueType) {
   switch (valueType) {
     case "number": {
@@ -943,7 +966,7 @@ function compileIndexWhereOperand(ctx, operand) {
     return ctx.systemColumn(operand.column);
   }
   const adapter = getDialect(ctx.dialect);
-  const pointer = chunk7V335GHG_cjs.jsonPointer([operand.field]);
+  const pointer = chunkFLRCVI2G_cjs.jsonPointer([operand.field]);
   switch (operand.valueType) {
     case "number": {
       return adapter.jsonExtractNumber(ctx.propsColumn, pointer);
@@ -1012,435 +1035,28 @@ function escapeStringLiteral(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
 
-// src/indexes/ddl.ts
-function generateIndexDDL(index, dialect, options = {}) {
-  if (index.entity === "node") {
-    return generateNodeIndexDDL(index, dialect, options);
-  }
-  return generateEdgeIndexDDL(index, dialect, options);
-}
-function generateNodeIndexDDL(index, dialect, options = {}) {
-  const tableName = options.nodesTableName ?? "typegraph_nodes";
-  return generateTableIndexDDL(index, dialect, tableName, options);
-}
-function generateEdgeIndexDDL(index, dialect, options = {}) {
-  const tableName = options.edgesTableName ?? "typegraph_edges";
-  return generateTableIndexDDL(index, dialect, tableName, options);
-}
-function generateTableIndexDDL(index, dialect, tableName, options) {
-  const ifNotExists = options.ifNotExists ?? true;
-  const propsColumn = drizzleOrm.sql.raw('"props"');
-  const systemColumn = (column) => drizzleOrm.sql.raw(quoteIdentifier3(column));
-  const keys = index.entity === "node" ? compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;
-  const whereSql = index.where ? sqlToInlineString(
-    compileIndexWhere(
-      {
-        dialect,
-        propsColumn,
-        systemColumn
-      },
-      index.where
-    ),
-    dialect
-  ) : void 0;
-  const keySql = keys.map((k) => sqlToInlineString(k, dialect)).join(", ");
-  const unique = index.unique ? "UNIQUE " : "";
-  const concurrent = options.concurrent === true && dialect === "postgres" ? "CONCURRENTLY " : "";
-  const ifNotExistsSql = ifNotExists ? "IF NOT EXISTS " : "";
-  const whereClause = whereSql ? ` WHERE ${whereSql}` : "";
-  return `CREATE ${unique}INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier3(index.name)} ON ${quoteIdentifier3(tableName)} (${keySql})${whereClause};`;
-}
-function quoteIdentifier3(identifier) {
-  return `"${identifier.replaceAll('"', '""')}"`;
-}
-function sqlToInlineString(object, dialect) {
-  const query = object.toQuery({
-    casing: new casing.CasingCache(),
-    escapeName: (name) => name,
-    escapeParam: (_number, value) => inlineParam(value, dialect),
-    escapeString: (value) => escapeStringLiteral2(value),
-    inlineParams: true,
-    invokeSource: "indexes"
-  });
-  if (query.params.length > 0) {
-    throw new Error(
-      "Index DDL generation produced parameters; expected fully inlined SQL"
-    );
-  }
-  return query.sql;
-}
-function inlineParam(value, dialect) {
-  if (value === null || value === void 0) {
-    return "NULL";
-  }
-  if (value instanceof Date) {
-    return escapeStringLiteral2(value.toISOString());
-  }
-  if (typeof value === "string") {
-    return escapeStringLiteral2(value);
-  }
-  if (typeof value === "number") {
-    return value.toString();
-  }
-  if (typeof value === "boolean") {
-    return getDialect(dialect).booleanLiteralString(value);
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  throw new TypeError(
-    "Index DDL generation received an unsupported SQL parameter value"
-  );
-}
-function escapeStringLiteral2(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function buildPostgresNodeIndexBuilders(table, indexes) {
-  const nodeIndexes = indexes.filter(
-    (index) => index.entity === "node"
-  );
-  return nodeIndexes.map((index) => {
-    const propsColumn = drizzleOrm.sql`${table.props}`;
-    const systemColumn = (column) => drizzleOrm.sql`${getPostgresNodeSystemColumn(table, column)}`;
-    const { keys } = compileNodeIndexKeys(
-      index,
-      "postgres",
-      propsColumn,
-      systemColumn
-    );
-    assertNonEmpty(keys, `node index "${index.name}"`);
-    const base = index.unique ? pgCore.uniqueIndex(index.name) : pgCore.index(index.name);
-    const builder = base.on(...keys);
-    if (index.where) {
-      const ctx = {
-        dialect: "postgres",
-        propsColumn,
-        systemColumn
-      };
-      builder.where(compileIndexWhere(ctx, index.where));
-    }
-    return builder;
-  });
-}
-function buildPostgresEdgeIndexBuilders(table, indexes) {
-  const edgeIndexes = indexes.filter(
-    (index) => index.entity === "edge"
-  );
-  return edgeIndexes.map((index) => {
-    const propsColumn = drizzleOrm.sql`${table.props}`;
-    const systemColumn = (column) => drizzleOrm.sql`${getPostgresEdgeSystemColumn(table, column)}`;
-    const { keys } = compileEdgeIndexKeys(
-      index,
-      "postgres",
-      propsColumn,
-      systemColumn
-    );
-    assertNonEmpty(keys, `edge index "${index.name}"`);
-    const base = index.unique ? pgCore.uniqueIndex(index.name) : pgCore.index(index.name);
-    const builder = base.on(...keys);
-    if (index.where) {
-      const ctx = {
-        dialect: "postgres",
-        propsColumn,
-        systemColumn
-      };
-      builder.where(compileIndexWhere(ctx, index.where));
-    }
-    return builder;
-  });
-}
-function getPostgresNodeSystemColumn(table, column) {
-  switch (column) {
-    case "graph_id": {
-      return table.graphId;
-    }
-    case "kind": {
-      return table.kind;
-    }
-    case "id": {
-      return table.id;
-    }
-    case "from_kind":
-    case "from_id":
-    case "to_kind":
-    case "to_id": {
-      throw new Error(`Unsupported node system column for indexes: ${column}`);
-    }
-    case "deleted_at": {
-      return table.deletedAt;
-    }
-    case "valid_from": {
-      return table.validFrom;
-    }
-    case "valid_to": {
-      return table.validTo;
-    }
-    case "created_at": {
-      return table.createdAt;
-    }
-    case "updated_at": {
-      return table.updatedAt;
-    }
-    case "version": {
-      return table.version;
-    }
-  }
-}
-function getPostgresEdgeSystemColumn(table, column) {
-  switch (column) {
-    case "graph_id": {
-      return table.graphId;
-    }
-    case "kind": {
-      return table.kind;
-    }
-    case "id": {
-      return table.id;
-    }
-    case "from_kind": {
-      return table.fromKind;
-    }
-    case "from_id": {
-      return table.fromId;
-    }
-    case "to_kind": {
-      return table.toKind;
-    }
-    case "to_id": {
-      return table.toId;
-    }
-    case "deleted_at": {
-      return table.deletedAt;
-    }
-    case "valid_from": {
-      return table.validFrom;
-    }
-    case "valid_to": {
-      return table.validTo;
-    }
-    case "created_at": {
-      return table.createdAt;
-    }
-    case "updated_at": {
-      return table.updatedAt;
-    }
-    case "version": {
-      throw new Error(`Unsupported edge system column for indexes: ${column}`);
-    }
-  }
-}
-function buildSqliteNodeIndexBuilders(table, indexes) {
-  const nodeIndexes = indexes.filter(
-    (index) => index.entity === "node"
-  );
-  return nodeIndexes.map((index) => {
-    const propsColumn = drizzleOrm.sql`${table.props}`;
-    const systemColumn = (column) => drizzleOrm.sql`${getSqliteNodeSystemColumn(table, column)}`;
-    const { keys } = compileNodeIndexKeys(
-      index,
-      "sqlite",
-      propsColumn,
-      systemColumn
-    );
-    assertNonEmpty(keys, `node index "${index.name}"`);
-    const base = index.unique ? sqliteCore.uniqueIndex(index.name) : sqliteCore.index(index.name);
-    const builder = base.on(...keys);
-    if (index.where) {
-      const ctx = {
-        dialect: "sqlite",
-        propsColumn,
-        systemColumn
-      };
-      builder.where(compileIndexWhere(ctx, index.where));
-    }
-    return builder;
-  });
-}
-function buildSqliteEdgeIndexBuilders(table, indexes) {
-  const edgeIndexes = indexes.filter(
-    (index) => index.entity === "edge"
-  );
-  return edgeIndexes.map((index) => {
-    const propsColumn = drizzleOrm.sql`${table.props}`;
-    const systemColumn = (column) => drizzleOrm.sql`${getSqliteEdgeSystemColumn(table, column)}`;
-    const { keys } = compileEdgeIndexKeys(
-      index,
-      "sqlite",
-      propsColumn,
-      systemColumn
-    );
-    assertNonEmpty(keys, `edge index "${index.name}"`);
-    const base = index.unique ? sqliteCore.uniqueIndex(index.name) : sqliteCore.index(index.name);
-    const builder = base.on(...keys);
-    if (index.where) {
-      const ctx = {
-        dialect: "sqlite",
-        propsColumn,
-        systemColumn
-      };
-      builder.where(compileIndexWhere(ctx, index.where));
-    }
-    return builder;
-  });
-}
-function getSqliteNodeSystemColumn(table, column) {
-  switch (column) {
-    case "graph_id": {
-      return table.graphId;
-    }
-    case "kind": {
-      return table.kind;
-    }
-    case "id": {
-      return table.id;
-    }
-    case "from_kind":
-    case "from_id":
-    case "to_kind":
-    case "to_id": {
-      throw new Error(`Unsupported node system column for indexes: ${column}`);
-    }
-    case "deleted_at": {
-      return table.deletedAt;
-    }
-    case "valid_from": {
-      return table.validFrom;
-    }
-    case "valid_to": {
-      return table.validTo;
-    }
-    case "created_at": {
-      return table.createdAt;
-    }
-    case "updated_at": {
-      return table.updatedAt;
-    }
-    case "version": {
-      return table.version;
-    }
-  }
-}
-function getSqliteEdgeSystemColumn(table, column) {
-  switch (column) {
-    case "graph_id": {
-      return table.graphId;
-    }
-    case "kind": {
-      return table.kind;
-    }
-    case "id": {
-      return table.id;
-    }
-    case "from_kind": {
-      return table.fromKind;
-    }
-    case "from_id": {
-      return table.fromId;
-    }
-    case "to_kind": {
-      return table.toKind;
-    }
-    case "to_id": {
-      return table.toId;
-    }
-    case "deleted_at": {
-      return table.deletedAt;
-    }
-    case "valid_from": {
-      return table.validFrom;
-    }
-    case "valid_to": {
-      return table.validTo;
-    }
-    case "created_at": {
-      return table.createdAt;
-    }
-    case "updated_at": {
-      return table.updatedAt;
-    }
-    case "version": {
-      throw new Error(`Unsupported edge system column for indexes: ${column}`);
-    }
-  }
-}
-function assertNonEmpty(values, label) {
-  if (values.length === 0) {
-    throw new Error(`Index must have at least one key (${label})`);
-  }
-}
-
-// src/indexes/profiler.ts
-function toDeclaredIndex(index) {
-  return {
-    entityType: index.entity,
-    kind: index.kind,
-    fields: [...index.fields],
-    unique: index.unique,
-    name: index.name
-  };
-}
-function toDeclaredIndexes(indexes) {
-  return indexes.filter(
-    (index) => index.entity === "node" || index.entity === "edge"
-  ).map((index) => toDeclaredIndex(index));
-}
-
-// src/indexes/where.ts
-function andWhere(...predicates) {
-  if (predicates.length === 1) {
-    return predicates[0];
-  }
-  return {
-    __type: "index_where_and",
-    predicates
-  };
-}
-function orWhere(...predicates) {
-  if (predicates.length === 1) {
-    return predicates[0];
-  }
-  return {
-    __type: "index_where_or",
-    predicates
-  };
-}
-function notWhere(predicate) {
-  return {
-    __type: "index_where_not",
-    predicate
-  };
-}
-
 exports.BASE_CONTRIBUTION_OWNER = BASE_CONTRIBUTION_OWNER;
 exports.VECTOR_CONTRIBUTION_PREFIX = VECTOR_CONTRIBUTION_PREFIX;
-exports.andWhere = andWhere;
 exports.assertFiniteEmbedding = assertFiniteEmbedding;
 exports.assertVectorMinScore = assertVectorMinScore;
 exports.assertVectorSearchLimit = assertVectorSearchLimit;
 exports.buildFulltextCapabilities = buildFulltextCapabilities;
-exports.buildPostgresEdgeIndexBuilders = buildPostgresEdgeIndexBuilders;
-exports.buildPostgresNodeIndexBuilders = buildPostgresNodeIndexBuilders;
-exports.buildSqliteEdgeIndexBuilders = buildSqliteEdgeIndexBuilders;
-exports.buildSqliteNodeIndexBuilders = buildSqliteNodeIndexBuilders;
 exports.buildVectorCapabilities = buildVectorCapabilities;
+exports.compileEdgeIndexKeys = compileEdgeIndexKeys;
+exports.compileIndexWhere = compileIndexWhere;
+exports.compileNodeIndexFieldKeys = compileNodeIndexFieldKeys;
+exports.compileNodeIndexKeys = compileNodeIndexKeys;
 exports.edgeColumnList = edgeColumnList;
 exports.fts5Strategy = fts5Strategy;
-exports.generateEdgeIndexDDL = generateEdgeIndexDDL;
-exports.generateIndexDDL = generateIndexDDL;
-exports.generateNodeIndexDDL = generateNodeIndexDDL;
 exports.getDialect = getDialect;
 exports.nodeColumnList = nodeColumnList;
-exports.notWhere = notWhere;
-exports.orWhere = orWhere;
 exports.quoteIdentifier = quoteIdentifier2;
 exports.quotedColumn = quotedColumn;
 exports.quotedTableName = quotedTableName;
 exports.sqlNull = sqlNull;
-exports.toDeclaredIndex = toDeclaredIndex;
-exports.toDeclaredIndexes = toDeclaredIndexes;
 exports.tsvectorStrategy = tsvectorStrategy;
 exports.vectorMinScoreCondition = vectorMinScoreCondition;
 exports.vectorPhysicalName = vectorPhysicalName;
 exports.vectorScoreExpression = vectorScoreExpression;
-//# sourceMappingURL=chunk-C2RWFIYP.cjs.map
-//# sourceMappingURL=chunk-C2RWFIYP.cjs.map
+//# sourceMappingURL=chunk-V4IQYOQ4.cjs.map
+//# sourceMappingURL=chunk-V4IQYOQ4.cjs.map