@nicia-ai/typegraph 0.24.1 → 0.25.0

package/dist/{chunk-753F33CV.js → chunk-YZZBDCLV.js}

@@ -1,5 +1,8 @@
-import { parseJsonPointer } from './chunk-EYELZHKY.js';
+import { parseJsonPointer, jsonPointer } from './chunk-NZ5PMBTG.js';
 import { sql } from 'drizzle-orm';
+import { CasingCache } from 'drizzle-orm/casing';
+import { uniqueIndex, index } from 'drizzle-orm/pg-core';
+import { uniqueIndex as uniqueIndex$1, index as index$1 } from 'drizzle-orm/sqlite-core';
 
 function sqlNull(value) {
   return value ?? sql.raw("NULL");
@@ -358,21 +361,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("'", "''")}'`;
 }
@@ -740,36 +728,621 @@ 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(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(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 sql`(${sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        sql` AND `
+      )})`;
+    }
+    case "index_where_or": {
+      return sql`(${sql.join(
+        expression.predicates.map((p) => compileIndexWhere(ctx, p)),
+        sql` OR `
+      )})`;
+    }
+    case "index_where_not": {
+      return sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;
+    }
+    case "index_where_null_check": {
+      const operand = compileIndexWhereOperand(ctx, expression.operand);
+      return expression.op === "isNull" ? sql`${operand} IS NULL` : 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" ? sql`IN` : sql`NOT IN`;
+        return sql`${left} ${operator} (${sql.join(values, 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 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 = 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 sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+    case "number": {
+      return sql.raw(literal.value.toString());
+    }
+    case "boolean": {
+      return getDialect(dialect).booleanLiteral(literal.value);
+    }
+    case "array":
+    case "object":
+    case "embedding":
+    case "unknown": {
+      return sql.raw(escapeStringLiteral(literal.value.toString()));
+    }
+  }
+}
+function compileComparisonOperator(op) {
+  switch (op) {
+    case "eq": {
+      return sql`=`;
+    }
+    case "neq": {
+      return sql`<>`;
+    }
+    case "gt": {
+      return sql`>`;
+    }
+    case "gte": {
+      return sql`>=`;
+    }
+    case "lt": {
+      return sql`<`;
+    }
+    case "lte": {
+      return 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 = sql.raw('"props"');
+  const systemColumn = (column) => 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 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$1) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getPostgresNodeSystemColumn(table, column)}`;
+    const { keys } = compileNodeIndexKeys(
+      index$1,
+      "postgres",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty(keys, `node index "${index$1.name}"`);
+    const base = index$1.unique ? uniqueIndex(index$1.name) : index(index$1.name);
+    const builder = base.on(...keys);
+    if (index$1.where) {
+      const ctx = {
+        dialect: "postgres",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index$1.where));
+    }
+    return builder;
+  });
+}
+function buildPostgresEdgeIndexBuilders(table, indexes) {
+  const edgeIndexes = indexes.filter(
+    (index) => index.entity === "edge"
+  );
+  return edgeIndexes.map((index$1) => {
+    const propsColumn = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getPostgresEdgeSystemColumn(table, column)}`;
+    const { keys } = compileEdgeIndexKeys(
+      index$1,
+      "postgres",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty(keys, `edge index "${index$1.name}"`);
+    const base = index$1.unique ? uniqueIndex(index$1.name) : index(index$1.name);
+    const builder = base.on(...keys);
+    if (index$1.where) {
+      const ctx = {
+        dialect: "postgres",
+        propsColumn,
+        systemColumn
+      };
+      builder.where(compileIndexWhere(ctx, index$1.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 = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getSqliteNodeSystemColumn(table, column)}`;
+    const { keys } = compileNodeIndexKeys(
+      index,
+      "sqlite",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty(keys, `node index "${index.name}"`);
+    const base = index.unique ? uniqueIndex$1(index.name) : index$1(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 = sql`${table.props}`;
+    const systemColumn = (column) => sql`${getSqliteEdgeSystemColumn(table, column)}`;
+    const { keys } = compileEdgeIndexKeys(
+      index,
+      "sqlite",
+      propsColumn,
+      systemColumn
+    );
+    assertNonEmpty(keys, `edge index "${index.name}"`);
+    const base = index.unique ? uniqueIndex$1(index.name) : index$1(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
+  };
+}
 
-export { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, EDGE_INDEX_TYPE_MARKER, EDGE_META_KEYS, IDENTIFIER_COMPONENT_MAX_LENGTH, MAX_PG_IDENTIFIER_LENGTH, NODE_INDEX_TYPE_MARKER, NODE_META_KEYS, PG_ARRAY_END, PG_ARRAY_START, PG_PATH_ELEMENT_SEPARATOR, SQLITE_PATH_DELIMITER, TRUNCATED_IDENTIFIER_MAX_LENGTH, buildFulltextCapabilities, edgeColumnList, fnv1aBase36, fts5Strategy, getDialect, nodeColumnList, quotedColumn, quotedTableName, sqlNull, tsvectorStrategy };
-//# sourceMappingURL=chunk-753F33CV.js.map
-//# sourceMappingURL=chunk-753F33CV.js.map
+export { andWhere, buildFulltextCapabilities, buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders, edgeColumnList, fts5Strategy, generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL, getDialect, nodeColumnList, notWhere, orWhere, quotedColumn, quotedTableName, sqlNull, toDeclaredIndex, toDeclaredIndexes, tsvectorStrategy };
+//# sourceMappingURL=chunk-YZZBDCLV.js.map
+//# sourceMappingURL=chunk-YZZBDCLV.js.map