@nicia-ai/typegraph 0.24.1 → 0.25.0

package/dist/{chunk-3JK66E3I.cjs → chunk-JTI5WT4P.cjs}

@@ -1,7 +1,10 @@
 'use strict';
 
-var chunkUVZHTBZ5_cjs = require('./chunk-UVZHTBZ5.cjs');
+var chunk7V335GHG_cjs = require('./chunk-7V335GHG.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");
@@ -360,21 +363,6 @@ var fts5Strategy = {
     return stmt === void 0 ? [] : [stmt];
   }
 };
-
-// src/constants.ts
-var MAX_PG_IDENTIFIER_LENGTH = 63;
-var TRUNCATED_IDENTIFIER_MAX_LENGTH = 54;
-var IDENTIFIER_COMPONENT_MAX_LENGTH = 20;
-var FNV1A_OFFSET_BASIS = 2166136261;
-var FNV1A_PRIME = 16777619;
-var DEFAULT_PAGINATION_LIMIT = 20;
-var DEFAULT_STREAM_BATCH_SIZE = 1e3;
-var NODE_INDEX_TYPE_MARKER = "typegraph_node_index";
-var EDGE_INDEX_TYPE_MARKER = "typegraph_edge_index";
-var SQLITE_PATH_DELIMITER = "|";
-var PG_PATH_ELEMENT_SEPARATOR = ",";
-var PG_ARRAY_START = "{";
-var PG_ARRAY_END = "}";
 function escapePostgresLiteral(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
@@ -382,7 +370,7 @@ function toPostgresPath(pointer) {
   if (!pointer || pointer === "" || pointer === "/") {
     return drizzleOrm.sql.raw("ARRAY[]::text[]");
   }
-  const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(pointer);
+  const segments = chunk7V335GHG_cjs.parseJsonPointer(pointer);
   if (segments.length === 0) {
     return drizzleOrm.sql.raw("ARRAY[]::text[]");
   }
@@ -554,7 +542,7 @@ function toSqlitePath(pointer) {
   if (!pointer || pointer === "" || pointer === "/") {
     return "$";
   }
-  const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(pointer);
+  const segments = chunk7V335GHG_cjs.parseJsonPointer(pointer);
   const parts = ["$"];
   for (const segment of segments) {
     if (isArrayIndex(segment)) {
@@ -742,58 +730,641 @@ var DIALECT_ADAPTERS = {
 function getDialect(dialect) {
   return DIALECT_ADAPTERS[dialect];
 }
+function compileNodeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  for (const column of getNodeScopeColumns(index.scope)) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(drizzleOrm.sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn) {
+  const adapter = getDialect(dialect);
+  const keys = [];
+  for (const column of getEdgeScopeColumns(index.scope, index.direction)) {
+    keys.push(systemColumn(column));
+  }
+  const allPointers = [...index.fields, ...index.coveringFields];
+  const allValueTypes = [
+    ...index.fieldValueTypes,
+    ...index.coveringFieldValueTypes
+  ];
+  for (const [pointerIndex, pointer] of allPointers.entries()) {
+    const valueType = allValueTypes[pointerIndex];
+    const extracted = compileIndexKeyValue(
+      adapter,
+      propsColumn,
+      pointer,
+      valueType
+    );
+    keys.push(drizzleOrm.sql`(${extracted})`);
+  }
+  return { keys };
+}
+function compileIndexKeyValue(dialect, propsColumn, pointer, valueType) {
+  switch (valueType) {
+    case "number": {
+      return dialect.jsonExtractNumber(propsColumn, pointer);
+    }
+    case "boolean": {
+      return dialect.jsonExtractBoolean(propsColumn, pointer);
+    }
+    case "date": {
+      return dialect.jsonExtractDate(propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return dialect.jsonExtractText(propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return dialect.jsonExtract(propsColumn, pointer);
+    }
+  }
+}
+function getNodeScopeColumns(scope) {
+  switch (scope) {
+    case "graphAndKind": {
+      return ["graph_id", "kind"];
+    }
+    case "graph": {
+      return ["graph_id"];
+    }
+    case "none": {
+      return [];
+    }
+  }
+}
+function getEdgeScopeColumns(scope, direction) {
+  const base = scope === "graphAndKind" ? ["graph_id", "kind"] : scope === "graph" ? ["graph_id"] : [];
+  if (direction === "out") {
+    return [...base, "from_id"];
+  }
+  if (direction === "in") {
+    return [...base, "to_id"];
+  }
+  return [...base];
+}
+function isIndexWhereLiteralList(value) {
+  return Array.isArray(value);
+}
+function compileIndexWhere(ctx, expression) {
+  switch (expression.__type) {
+    case "index_where_and": {
+      return drizzleOrm.sql`(${drizzleOrm.sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        drizzleOrm.sql` AND `
+      )})`;
+    }
+    case "index_where_or": {
+      return drizzleOrm.sql`(${drizzleOrm.sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        drizzleOrm.sql` OR `
+      )})`;
+    }
+    case "index_where_not": {
+      return drizzleOrm.sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;
+    }
+    case "index_where_null_check": {
+      const operand = compileIndexWhereOperand(ctx, expression.operand);
+      return expression.op === "isNull" ? drizzleOrm.sql`${operand} IS NULL` : drizzleOrm.sql`${operand} IS NOT NULL`;
+    }
+    case "index_where_comparison": {
+      const left = compileIndexWhereOperand(ctx, expression.left);
+      const right = expression.right;
+      if (isIndexWhereLiteralList(right)) {
+        if (expression.op !== "in" && expression.op !== "notIn") {
+          throw new Error(
+            `Operator "${expression.op}" does not support list comparison in index WHERE clause`
+          );
+        }
+        const values = right.map(
+          (literal) => compileIndexWhereLiteral(ctx.dialect, literal)
+        );
+        const operator = expression.op === "in" ? drizzleOrm.sql`IN` : drizzleOrm.sql`NOT IN`;
+        return drizzleOrm.sql`${left} ${operator} (${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)})`;
+      }
+      if (expression.op === "in" || expression.op === "notIn") {
+        throw new Error(
+          `Operator "${expression.op}" requires a list of values in index WHERE clause`
+        );
+      }
+      const rightLiteral = compileIndexWhereLiteral(ctx.dialect, right);
+      const opSql = compileComparisonOperator(expression.op);
+      return drizzleOrm.sql`${left} ${opSql} ${rightLiteral}`;
+    }
+  }
+}
+function compileIndexWhereOperand(ctx, operand) {
+  if (operand.__type === "index_operand_system") {
+    return ctx.systemColumn(operand.column);
+  }
+  const adapter = getDialect(ctx.dialect);
+  const pointer = chunk7V335GHG_cjs.jsonPointer([operand.field]);
+  switch (operand.valueType) {
+    case "number": {
+      return adapter.jsonExtractNumber(ctx.propsColumn, pointer);
+    }
+    case "boolean": {
+      return adapter.jsonExtractBoolean(ctx.propsColumn, pointer);
+    }
+    case "date": {
+      return adapter.jsonExtractDate(ctx.propsColumn, pointer);
+    }
+    case "array":
+    case "object":
+    case "embedding": {
+      return adapter.jsonExtract(ctx.propsColumn, pointer);
+    }
+    case "string":
+    case "unknown":
+    case void 0: {
+      return adapter.jsonExtractText(ctx.propsColumn, pointer);
+    }
+  }
+}
+function compileIndexWhereLiteral(dialect, literal) {
+  switch (literal.valueType) {
+    case "string":
+    case "date": {
+      return drizzleOrm.sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+    case "number": {
+      return drizzleOrm.sql.raw(literal.value.toString());
+    }
+    case "boolean": {
+      return getDialect(dialect).booleanLiteral(literal.value);
+    }
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown": {
+      return drizzleOrm.sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+  }
+}
+function compileComparisonOperator(op) {
+  switch (op) {
+    case "eq": {
+      return drizzleOrm.sql`=`;
+    }
+    case "neq": {
+      return drizzleOrm.sql`<>`;
+    }
+    case "gt": {
+      return drizzleOrm.sql`>`;
+    }
+    case "gte": {
+      return drizzleOrm.sql`>=`;
+    }
+    case "lt": {
+      return drizzleOrm.sql`<`;
+    }
+    case "lte": {
+      return drizzleOrm.sql`<=`;
+    }
+  }
+}
+function escapeStringLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
 
-// src/utils/hash.ts
-function fnv1aBase36(input) {
-  let hash = FNV1A_OFFSET_BASIS;
-  for (const character of input) {
-    const codePoint = character.codePointAt(0);
-    if (codePoint === void 0) continue;
-    hash ^= codePoint;
-    hash = Math.imul(hash, FNV1A_PRIME);
+// 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(quoteIdentifier2(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}${quoteIdentifier2(index.name)} ON ${quoteIdentifier2(tableName)} (${keySql})${whereClause};`;
+}
+function quoteIdentifier2(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})`);
   }
-  return (hash >>> 0).toString(36);
 }
 
-// src/system-fields.ts
-var NODE_META_KEYS = [
-  "version",
-  "validFrom",
-  "validTo",
-  "createdAt",
-  "updatedAt",
-  "deletedAt"
-];
-var EDGE_META_KEYS = [
-  "validFrom",
-  "validTo",
-  "createdAt",
-  "updatedAt",
-  "deletedAt"
-];
+// 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.DEFAULT_PAGINATION_LIMIT = DEFAULT_PAGINATION_LIMIT;
-exports.DEFAULT_STREAM_BATCH_SIZE = DEFAULT_STREAM_BATCH_SIZE;
-exports.EDGE_INDEX_TYPE_MARKER = EDGE_INDEX_TYPE_MARKER;
-exports.EDGE_META_KEYS = EDGE_META_KEYS;
-exports.IDENTIFIER_COMPONENT_MAX_LENGTH = IDENTIFIER_COMPONENT_MAX_LENGTH;
-exports.MAX_PG_IDENTIFIER_LENGTH = MAX_PG_IDENTIFIER_LENGTH;
-exports.NODE_INDEX_TYPE_MARKER = NODE_INDEX_TYPE_MARKER;
-exports.NODE_META_KEYS = NODE_META_KEYS;
-exports.PG_ARRAY_END = PG_ARRAY_END;
-exports.PG_ARRAY_START = PG_ARRAY_START;
-exports.PG_PATH_ELEMENT_SEPARATOR = PG_PATH_ELEMENT_SEPARATOR;
-exports.SQLITE_PATH_DELIMITER = SQLITE_PATH_DELIMITER;
-exports.TRUNCATED_IDENTIFIER_MAX_LENGTH = TRUNCATED_IDENTIFIER_MAX_LENGTH;
+exports.andWhere = andWhere;
 exports.buildFulltextCapabilities = buildFulltextCapabilities;
+exports.buildPostgresEdgeIndexBuilders = buildPostgresEdgeIndexBuilders;
+exports.buildPostgresNodeIndexBuilders = buildPostgresNodeIndexBuilders;
+exports.buildSqliteEdgeIndexBuilders = buildSqliteEdgeIndexBuilders;
+exports.buildSqliteNodeIndexBuilders = buildSqliteNodeIndexBuilders;
 exports.edgeColumnList = edgeColumnList;
-exports.fnv1aBase36 = fnv1aBase36;
 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.quotedColumn = quotedColumn;
 exports.quotedTableName = quotedTableName;
 exports.sqlNull = sqlNull;
+exports.toDeclaredIndex = toDeclaredIndex;
+exports.toDeclaredIndexes = toDeclaredIndexes;
 exports.tsvectorStrategy = tsvectorStrategy;
-//# sourceMappingURL=chunk-3JK66E3I.cjs.map
-//# sourceMappingURL=chunk-3JK66E3I.cjs.map
+//# sourceMappingURL=chunk-JTI5WT4P.cjs.map
+//# sourceMappingURL=chunk-JTI5WT4P.cjs.map