@nicia-ai/typegraph 0.20.0 → 0.22.0

package/dist/{chunk-QFZQGEQ3.js → chunk-5ZMMHUWR.js}

@@ -1,6 +1,6 @@
 import { DatabaseOperationError, UniquenessError } from './chunk-WFMTAEEN.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders } from './chunk-6GWJH6AR.js';
-import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-GNIYZKBI.js';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteEdgeIndexBuilders } from './chunk-3PPEHLGK.js';
+import { tsvectorStrategy, fts5Strategy, MAX_PG_IDENTIFIER_LENGTH, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-753F33CV.js';
 import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, getTableConfig as getTableConfig$1 } from 'drizzle-orm/pg-core';
 import { sqliteTable, text as text$1, integer as integer$1, primaryKey as primaryKey$1, index as index$1, blob, getTableConfig } from 'drizzle-orm/sqlite-core';
 import { sql, getTableName } from 'drizzle-orm';
@@ -67,7 +67,8 @@ var DEFAULT_TABLE_NAMES = {
   edges: "typegraph_edges",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
-  embeddings: "typegraph_node_embeddings"
+  embeddings: "typegraph_node_embeddings",
+  fulltext: "typegraph_node_fulltext"
 };
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
@@ -224,7 +225,23 @@ function createPostgresTables(names = {}, options = {}) {
       )
     ]
   );
-  return { nodes: nodes3, edges: edges3, uniques: uniques3, schemaVersions: schemaVersions3, embeddings: embeddings3 };
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    uniques: uniques3,
+    schemaVersions: schemaVersions3,
+    embeddings: embeddings3,
+    /**
+     * The fulltext storage table is owned by the active `FulltextStrategy`,
+     * not Drizzle. Shapes vary across strategies — the default `tsvectorStrategy`
+     * uses a `regconfig` language column, a GENERATED STORED `tsv` column,
+     * and a GIN index; alternate strategies (ParadeDB, pg_trgm, pgroonga)
+     * pick their own column types and index methods. DDL is emitted as
+     * raw SQL via `strategy.generateDdl()`; reads and writes are composed
+     * from the strategy's fragment helpers.
+     */
+    fulltextTableName: n.fulltext
+  };
 }
 var tables = createPostgresTables();
 var { nodes, edges, uniques, schemaVersions, embeddings } = tables;
@@ -233,7 +250,8 @@ var DEFAULT_TABLE_NAMES2 = {
   edges: "typegraph_edges",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
-  embeddings: "typegraph_node_embeddings"
+  embeddings: "typegraph_node_embeddings",
+  fulltext: "typegraph_node_fulltext"
 };
 function createSqliteTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES2, ...names };
@@ -394,7 +412,19 @@ function createSqliteTables(names = {}, options = {}) {
       )
     ]
   );
-  return { nodes: nodes3, edges: edges3, uniques: uniques3, schemaVersions: schemaVersions3, embeddings: embeddings3 };
+  return {
+    nodes: nodes3,
+    edges: edges3,
+    uniques: uniques3,
+    schemaVersions: schemaVersions3,
+    embeddings: embeddings3,
+    /**
+     * The fulltext storage is a FTS5 virtual table which Drizzle cannot
+     * represent. DDL is emitted as raw SQL and operations query it via
+     * `sql.raw()`.
+     */
+    fulltextTableName: n.fulltext
+  };
 }
 var tables2 = createSqliteTables();
 var { nodes: nodes2, edges: edges2, uniques: uniques2, schemaVersions: schemaVersions2, embeddings: embeddings2 } = tables2;
@@ -473,8 +503,17 @@ function flattenSqlChunk(chunk) {
     return chunk;
   }
   if (typeof chunk === "object" && chunk !== null) {
-    if ("value" in chunk && Array.isArray(chunk.value)) {
-      return chunk.value.map((part) => flattenSqlChunk(part)).join("");
+    if ("name" in chunk && typeof chunk.name === "string") {
+      return `"${chunk.name}"`;
+    }
+    if ("value" in chunk) {
+      const value = chunk.value;
+      if (typeof value === "string") {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((part) => flattenSqlChunk(part)).join("");
+      }
     }
     if ("queryChunks" in chunk && Array.isArray(chunk.queryChunks)) {
       return chunk.queryChunks.map((part) => flattenSqlChunk(part)).join("");
@@ -516,18 +555,25 @@ function generateSqliteCreateIndexSQL(table) {
   }
   return statements;
 }
-function generateSqliteDDL(tables3 = tables2) {
+function isSqliteTable(value) {
+  return typeof value === "object" && value !== null && // Drizzle tables are always objects; strings are our escape hatch.
+  typeof value !== "string";
+}
+function generateSqliteDDL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
   const statements = [];
   for (const table of Object.values(tables3)) {
+    if (!isSqliteTable(table)) continue;
     statements.push(generateSqliteCreateTableSQL(table));
   }
   for (const table of Object.values(tables3)) {
+    if (!isSqliteTable(table)) continue;
     statements.push(...generateSqliteCreateIndexSQL(table));
   }
+  statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
   return statements;
 }
-function generateSqliteMigrationSQL(tables3 = tables2) {
-  return generateSqliteDDL(tables3).join("\n\n");
+function generateSqliteMigrationSQL(tables3 = tables2, fulltextStrategy = fts5Strategy) {
+  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
   switch (column.columnType) {
@@ -608,19 +654,25 @@ function generatePgCreateIndexSQL(table) {
   }
   return statements;
 }
-function generatePostgresDDL(tables3 = tables) {
+function isPgTable(value) {
+  return typeof value === "object" && value !== null && typeof value !== "string";
+}
+function generatePostgresDDL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
   const statements = [];
   for (const table of Object.values(tables3)) {
+    if (!isPgTable(table)) continue;
     statements.push(generatePgCreateTableSQL(table));
   }
   for (const table of Object.values(tables3)) {
+    if (!isPgTable(table)) continue;
     statements.push(...generatePgCreateIndexSQL(table));
   }
+  statements.push(...fulltextStrategy.generateDdl(tables3.fulltextTableName));
   return statements;
 }
-function generatePostgresMigrationSQL(tables3 = tables) {
+function generatePostgresMigrationSQL(tables3 = tables, fulltextStrategy = tsvectorStrategy) {
   const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
-  const ddlSql = generatePostgresDDL(tables3).join("\n\n");
+  const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
   return `${extensionSql}
 
 ${ddlSql}`;
@@ -847,6 +899,14 @@ function createCommonOperationBackend(options) {
         params.id
       );
       await execution.execRun(deleteEmbeddingsQuery);
+      const deleteFulltextStatements = operationStrategy.buildDeleteFulltextByNode(
+        params.graphId,
+        params.kind,
+        params.id
+      );
+      for (const stmt of deleteFulltextStatements) {
+        await execution.execRun(stmt);
+      }
       const deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
         params.graphId,
         params.kind,
@@ -1021,7 +1081,9 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
+  const fulltext = quotedTableName(tables3.fulltextTableName);
   return [
+    sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}`,
     sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
@@ -1056,12 +1118,16 @@ function buildFindNodesByKind(tables3, params) {
     sql`${nodes3.kind} = ${params.kind}`,
     ...buildTemporalConditions(nodes3, params)
   ];
+  if (params.orderBy === "id" && params.after !== void 0) {
+    conditions.push(sql`${nodes3.id} > ${params.after}`);
+  }
   const whereClause = sql.join(conditions, sql` AND `);
+  const orderByClause = params.orderBy === "id" ? sql`${nodes3.id} ASC` : sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return sql`
       SELECT * FROM ${nodes3}
       WHERE ${whereClause}
-      ORDER BY ${nodes3.createdAt} DESC
+      ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
     `;
   }
@@ -1069,14 +1135,14 @@ function buildFindNodesByKind(tables3, params) {
     return sql`
       SELECT * FROM ${nodes3}
       WHERE ${whereClause}
-      ORDER BY ${nodes3.createdAt} DESC
+      ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return sql`
     SELECT * FROM ${nodes3}
     WHERE ${whereClause}
-    ORDER BY ${nodes3.createdAt} DESC
+    ORDER BY ${orderByClause}
   `;
 }
 function buildCountNodesByKind(tables3, params) {
@@ -1159,20 +1225,6 @@ function buildCountEdgesByKind(tables3, params) {
     WHERE ${whereClause}
   `;
 }
-function sqlNull(value) {
-  return value ?? sql.raw("NULL");
-}
-function quotedColumn(column) {
-  return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function nodeColumnList(nodes3) {
-  return sql.raw(`"${nodes3.graphId.name}", "${nodes3.kind.name}", "${nodes3.id.name}", "${nodes3.props.name}", "${nodes3.version.name}", "${nodes3.validFrom.name}", "${nodes3.validTo.name}", "${nodes3.createdAt.name}", "${nodes3.updatedAt.name}"`);
-}
-function edgeColumnList(edges3) {
-  return sql.raw(`"${edges3.graphId.name}", "${edges3.id.name}", "${edges3.kind.name}", "${edges3.fromKind.name}", "${edges3.fromId.name}", "${edges3.toKind.name}", "${edges3.toId.name}", "${edges3.props.name}", "${edges3.validFrom.name}", "${edges3.validTo.name}", "${edges3.createdAt.name}", "${edges3.updatedAt.name}"`);
-}
-
-// src/backend/drizzle/operations/edges.ts
 function buildInsertEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
@@ -1364,6 +1416,60 @@ function buildFindEdgesConnectedTo(tables3, params) {
       )
   `;
 }
+function resolveMode(mode) {
+  return mode ?? "websearch";
+}
+function buildFulltextSearch(tableName, params, strategy) {
+  assertValidSearchParams(params);
+  const mode = resolveMode(params.mode);
+  const table = quotedTableName(tableName);
+  const matchCondition = strategy.matchCondition(
+    tableName,
+    params.query,
+    mode,
+    params.language
+  );
+  const rankExpression = strategy.rankExpression(
+    tableName,
+    params.query,
+    mode,
+    params.language
+  );
+  const conditions = [
+    matchCondition,
+    sql`"graph_id" = ${params.graphId}`,
+    sql`"node_kind" = ${params.nodeKind}`
+  ];
+  if (params.minScore !== void 0) {
+    conditions.push(sql`${rankExpression} >= ${params.minScore}`);
+  }
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? strategy.snippetExpression(
+    tableName,
+    params.query,
+    mode,
+    params.language
+  ) : sql`NULL`;
+  return sql`
+    SELECT
+      "node_id" AS node_id,
+      ${rankExpression} AS score,
+      ${snippetExpr} AS snippet
+    FROM ${table}
+    WHERE ${sql.join(conditions, sql` AND `)}
+    ORDER BY ${rankExpression} DESC, "node_id" ASC
+    LIMIT ${params.limit}
+  `;
+}
+function assertValidSearchParams(params) {
+  if (!Number.isInteger(params.limit) || params.limit <= 0) {
+    throw new Error(`limit must be a positive integer, got: ${params.limit}`);
+  }
+  if (params.minScore !== void 0 && !Number.isFinite(params.minScore)) {
+    throw new TypeError(
+      `minScore must be a finite number, got: ${params.minScore}`
+    );
+  }
+}
 function buildInsertNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
@@ -1738,6 +1844,30 @@ function buildUpsertEmbeddingPostgres(tables3, params, timestamp2) {
       ${column(embeddings3.updatedAt)} = ${timestamp2}
   `;
 }
+function buildUpsertEmbeddingSqlite(tables3, params, timestamp2) {
+  const { embeddings: embeddings3 } = tables3;
+  const embeddingJson = JSON.stringify(params.embedding);
+  assertFiniteNumberArray(params.embedding, "embedding");
+  const columns = sql.raw(
+    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}", "${embeddings3.embedding.name}", "${embeddings3.dimensions.name}", "${embeddings3.createdAt.name}", "${embeddings3.updatedAt.name}"`
+  );
+  const conflictColumns = sql.raw(
+    `"${embeddings3.graphId.name}", "${embeddings3.nodeKind.name}", "${embeddings3.nodeId.name}", "${embeddings3.fieldPath.name}"`
+  );
+  const column = (target) => sql.raw(`"${target.name}"`);
+  return sql`
+    INSERT INTO ${embeddings3} (${columns})
+    VALUES (
+      ${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.fieldPath},
+      vec_f32(${embeddingJson}), ${params.dimensions}, ${timestamp2}, ${timestamp2}
+    )
+    ON CONFLICT (${conflictColumns})
+    DO UPDATE SET
+      ${column(embeddings3.embedding)} = vec_f32(${embeddingJson}),
+      ${column(embeddings3.dimensions)} = ${params.dimensions},
+      ${column(embeddings3.updatedAt)} = ${timestamp2}
+  `;
+}
 function buildDeleteEmbedding(tables3, params) {
   const { embeddings: embeddings3 } = tables3;
   return sql`
@@ -1901,13 +2031,27 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCheckUniqueBatch,
   buildGetSchemaVersion
 };
-function createCommonOperationStrategy(tables3, dialect) {
+function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
   const tableOperations = bindTableOperationBuilders(
     tables3,
     COMMON_TABLE_OPERATION_BUILDERS
   );
+  const fulltextTable = tables3.fulltextTableName;
+  const fulltextBuilders = {
+    buildUpsertFulltext: (params, timestamp2) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp2),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params),
+    buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
+      graphId,
+      nodeKind,
+      nodeId
+    }),
+    buildUpsertFulltextBatch: (params, timestamp2) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp2),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params),
+    buildFulltextSearch: (params) => buildFulltextSearch(fulltextTable, params, fulltextStrategy)
+  };
   return {
     ...tableOperations,
+    ...fulltextBuilders,
     buildInsertUnique(params) {
       return buildInsertUnique(tables3, dialect, params);
     },
@@ -1925,11 +2069,28 @@ function createCommonOperationStrategy(tables3, dialect) {
     }
   };
 }
-function createSqliteOperationStrategy(tables3) {
-  return createCommonOperationStrategy(tables3, "sqlite");
+function createSqliteOperationStrategy(tables3, fulltextStrategy) {
+  const common = createCommonOperationStrategy(
+    tables3,
+    "sqlite",
+    fulltextStrategy
+  );
+  return {
+    ...common,
+    buildUpsertEmbedding(params, timestamp2) {
+      return buildUpsertEmbeddingSqlite(tables3, params, timestamp2);
+    },
+    buildDeleteEmbedding(params) {
+      return buildDeleteEmbedding(tables3, params);
+    }
+  };
 }
-function createPostgresOperationStrategy(tables3) {
-  const common = createCommonOperationStrategy(tables3, "postgres");
+function createPostgresOperationStrategy(tables3, fulltextStrategy) {
+  const common = createCommonOperationStrategy(
+    tables3,
+    "postgres",
+    fulltextStrategy
+  );
   return {
     ...common,
     buildUpsertEmbedding(params, timestamp2) {
@@ -2133,5 +2294,5 @@ function compileQueryWithDialect(db, query, backendName) {
 }
 
 export { POSTGRES_CAPABILITIES, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CAPABILITIES, SQLITE_ROW_MAPPER_CONFIG, compileQueryWithDialect, createCommonOperationBackend, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createPostgresVectorIndex, createSchemaVersionRowMapper, createSqliteOperationStrategy, createSqliteTables, createSqliteVectorIndex, createUniqueRowMapper, dropPostgresVectorIndex, dropSqliteVectorIndex, edges, edges2, embeddings, embeddings2, formatPostgresTimestamp, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteDDL, generateSqliteMigrationSQL, generateVectorIndexName, nodes, nodes2, nowIso, schemaVersions, schemaVersions2, tables, tables2, uniques, uniques2, wrapWithManagedClose };
-//# sourceMappingURL=chunk-QFZQGEQ3.js.map
-//# sourceMappingURL=chunk-QFZQGEQ3.js.map
+//# sourceMappingURL=chunk-5ZMMHUWR.js.map
+//# sourceMappingURL=chunk-5ZMMHUWR.js.map