@nicia-ai/typegraph 0.29.0 → 0.31.0

package/dist/{chunk-7KLVFWXR.js → chunk-2HZGWCB4.js}

@@ -1,8 +1,5 @@
-import { parseJsonPointer, jsonPointer } from './chunk-NZ5PMBTG.js';
+import { jsonPointer, parseJsonPointer } from './chunk-K5P5OZXS.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");
@@ -382,6 +379,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 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 sql`${distanceExpression} <= ${1 - minScore}`;
+    }
+    case "l2": {
+      return sql`${distanceExpression} <= ${minScore}`;
+    }
+    case "inner_product": {
+      return 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("'", "''")}'`;
 }
@@ -477,6 +565,12 @@ var postgresDialect = {
     return sql`(${column} #> ${path} IS NOT NULL AND ${column} #>> ${path} != 'null')`;
   },
   // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return sql`${left} IS NOT DISTINCT FROM ${right}`;
+  },
+  // ============================================================
   // String Operations
   // ============================================================
   ilike(column, pattern) {
@@ -636,6 +730,12 @@ var sqliteDialect = {
     return sql`(json_extract(${column}, ${pathSql}) IS NOT NULL AND json_type(${column}, ${pathSql}) != 'null')`;
   },
   // ============================================================
+  // Comparison Operations
+  // ============================================================
+  nullSafeEquals(left, right) {
+    return sql`${left} IS ${right}`;
+  },
+  // ============================================================
   // String Operations
   // ============================================================
   ilike(column, pattern) {
@@ -694,97 +794,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 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 sql`${distanceExpression} <= ${1 - minScore}`;
-    }
-    case "l2": {
-      return sql`${distanceExpression} <= ${minScore}`;
-    }
-    case "inner_product": {
-      return 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 = {
@@ -840,6 +849,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(sql`(${extracted})`);
+  }
+  return keys;
+}
 function compileIndexKeyValue(dialect, propsColumn, pointer, valueType) {
   switch (valueType) {
     case "number": {
@@ -1010,405 +1033,6 @@ 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 = sql.raw('"props"');
-  const systemColumn = (column) => 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 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})`);
-  }
-}
-
-// 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 { BASE_CONTRIBUTION_OWNER, VECTOR_CONTRIBUTION_PREFIX, andWhere, assertFiniteEmbedding, assertVectorMinScore, assertVectorSearchLimit, buildFulltextCapabilities, buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildVectorCapabilities, edgeColumnList, fts5Strategy, generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL, getDialect, nodeColumnList, notWhere, orWhere, quoteIdentifier2 as quoteIdentifier, quotedColumn, quotedTableName, sqlNull, toDeclaredIndex, toDeclaredIndexes, tsvectorStrategy, vectorMinScoreCondition, vectorPhysicalName, vectorScoreExpression };
-//# sourceMappingURL=chunk-7KLVFWXR.js.map
-//# sourceMappingURL=chunk-7KLVFWXR.js.map
+export { BASE_CONTRIBUTION_OWNER, VECTOR_CONTRIBUTION_PREFIX, assertFiniteEmbedding, assertVectorMinScore, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, compileEdgeIndexKeys, compileIndexWhere, compileNodeIndexFieldKeys, compileNodeIndexKeys, edgeColumnList, fts5Strategy, getDialect, nodeColumnList, quoteIdentifier2 as quoteIdentifier, quotedColumn, quotedTableName, sqlNull, tsvectorStrategy, vectorMinScoreCondition, vectorPhysicalName, vectorScoreExpression };
+//# sourceMappingURL=chunk-2HZGWCB4.js.map
+//# sourceMappingURL=chunk-2HZGWCB4.js.map