@nicia-ai/typegraph 0.19.0 → 0.21.0

package/dist/{chunk-IYWWXOVK.cjs → chunk-Q73OWTJY.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chunkO5PST6TB_cjs = require('./chunk-O5PST6TB.cjs');
-var chunkLELLOHJK_cjs = require('./chunk-LELLOHJK.cjs');
-var chunkMME3H4ZF_cjs = require('./chunk-MME3H4ZF.cjs');
+var chunk2X7P7AD5_cjs = require('./chunk-2X7P7AD5.cjs');
+var chunkFQCQM3KG_cjs = require('./chunk-FQCQM3KG.cjs');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
 var drizzleOrm = require('drizzle-orm');
@@ -69,7 +69,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 };
@@ -99,7 +100,7 @@ function createPostgresTables(names = {}, options = {}) {
       ),
       pgCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       pgCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkLELLOHJK_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+      ...chunk2X7P7AD5_cjs.buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = pgCore.pgTable(
@@ -158,7 +159,7 @@ function createPostgresTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkLELLOHJK_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+      ...chunk2X7P7AD5_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = pgCore.pgTable(
@@ -226,7 +227,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;
@@ -235,7 +252,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 };
@@ -265,7 +283,7 @@ function createSqliteTables(names = {}, options = {}) {
       ),
       sqliteCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
       sqliteCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkLELLOHJK_cjs.buildSqliteNodeIndexBuilders(t, indexes)
+      ...chunk2X7P7AD5_cjs.buildSqliteNodeIndexBuilders(t, indexes)
     ]
   );
   const edges3 = sqliteCore.sqliteTable(
@@ -324,7 +342,7 @@ function createSqliteTables(names = {}, options = {}) {
         t.fromId,
         t.validTo
       ),
-      ...chunkLELLOHJK_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
+      ...chunk2X7P7AD5_cjs.buildSqliteEdgeIndexBuilders(t, indexes)
     ]
   );
   const uniques3 = sqliteCore.sqliteTable(
@@ -396,7 +414,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;
@@ -518,18 +548,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 = chunkFQCQM3KG_cjs.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 = chunkFQCQM3KG_cjs.fts5Strategy) {
+  return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
   switch (column.columnType) {
@@ -610,19 +647,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 = chunkFQCQM3KG_cjs.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 = chunkFQCQM3KG_cjs.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}`;
@@ -849,6 +892,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,
@@ -1023,7 +1074,9 @@ function createCommonOperationBackend(options) {
   };
 }
 function buildClearGraph(tables3, graphId) {
+  const fulltext = chunkFQCQM3KG_cjs.quotedTableName(tables3.fulltextTableName);
   return [
+    drizzleOrm.sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.embeddings} WHERE ${tables3.embeddings.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
     drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
@@ -1058,12 +1111,16 @@ function buildFindNodesByKind(tables3, params) {
     drizzleOrm.sql`${nodes3.kind} = ${params.kind}`,
     ...buildTemporalConditions(nodes3, params)
   ];
+  if (params.orderBy === "id" && params.after !== void 0) {
+    conditions.push(drizzleOrm.sql`${nodes3.id} > ${params.after}`);
+  }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
+  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes3.id} ASC` : drizzleOrm.sql`${nodes3.createdAt} DESC, ${nodes3.id} DESC`;
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
       SELECT * FROM ${nodes3}
       WHERE ${whereClause}
-      ORDER BY ${nodes3.createdAt} DESC
+      ORDER BY ${orderByClause}
       LIMIT ${params.limit} OFFSET ${params.offset}
     `;
   }
@@ -1071,14 +1128,14 @@ function buildFindNodesByKind(tables3, params) {
     return drizzleOrm.sql`
       SELECT * FROM ${nodes3}
       WHERE ${whereClause}
-      ORDER BY ${nodes3.createdAt} DESC
+      ORDER BY ${orderByClause}
       LIMIT ${params.limit}
     `;
   }
   return drizzleOrm.sql`
     SELECT * FROM ${nodes3}
     WHERE ${whereClause}
-    ORDER BY ${nodes3.createdAt} DESC
+    ORDER BY ${orderByClause}
   `;
 }
 function buildCountNodesByKind(tables3, params) {
@@ -1161,30 +1218,16 @@ function buildCountEdgesByKind(tables3, params) {
     WHERE ${whereClause}
   `;
 }
-function sqlNull(value) {
-  return value ?? drizzleOrm.sql.raw("NULL");
-}
-function quotedColumn(column) {
-  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function nodeColumnList(nodes3) {
-  return drizzleOrm.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 drizzleOrm.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);
-  const columns = edgeColumnList(edges3);
+  const columns = chunkFQCQM3KG_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${chunkFQCQM3KG_cjs.sqlNull(params.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1193,23 +1236,23 @@ function buildInsertEdge(tables3, params, timestamp2) {
 function buildInsertEdgeNoReturn(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges3);
+  const columns = chunkFQCQM3KG_cjs.edgeColumnList(edges3);
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${chunkFQCQM3KG_cjs.sqlNull(params.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertEdgesBatch(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = edgeColumnList(edges3);
+  const columns = chunkFQCQM3KG_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkFQCQM3KG_cjs.sqlNull(edgeParams.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1218,10 +1261,10 @@ function buildInsertEdgesBatch(tables3, params, timestamp2) {
 }
 function buildInsertEdgesBatchReturning(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
-  const columns = edgeColumnList(edges3);
+  const columns = chunkFQCQM3KG_cjs.edgeColumnList(edges3);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(edgeParams.validFrom)}, ${sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkFQCQM3KG_cjs.sqlNull(edgeParams.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(edgeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges3} (${columns})
@@ -1253,14 +1296,14 @@ function buildUpdateEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${quotedColumn(edges3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(edges3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(edges3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(edges3.updatedAt)} = ${timestamp2}`
   ];
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(edges3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(edges3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1285,7 +1328,7 @@ function buildDeleteEdge(tables3, params, timestamp2) {
   const { edges: edges3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${edges3}
-    SET ${quotedColumn(edges3.deletedAt)} = ${timestamp2}
+    SET ${chunkFQCQM3KG_cjs.quotedColumn(edges3.deletedAt)} = ${timestamp2}
     WHERE ${edges3.graphId} = ${params.graphId}
       AND ${edges3.id} = ${params.id}
       AND ${edges3.deletedAt} IS NULL
@@ -1366,15 +1409,69 @@ function buildFindEdgesConnectedTo(tables3, params) {
       )
   `;
 }
+function resolveMode(mode) {
+  return mode ?? "websearch";
+}
+function buildFulltextSearch(tableName, params, strategy) {
+  assertValidSearchParams(params);
+  const mode = resolveMode(params.mode);
+  const table = chunkFQCQM3KG_cjs.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,
+    drizzleOrm.sql`"graph_id" = ${params.graphId}`,
+    drizzleOrm.sql`"node_kind" = ${params.nodeKind}`
+  ];
+  if (params.minScore !== void 0) {
+    conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
+  }
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? strategy.snippetExpression(
+    tableName,
+    params.query,
+    mode,
+    params.language
+  ) : drizzleOrm.sql`NULL`;
+  return drizzleOrm.sql`
+    SELECT
+      "node_id" AS node_id,
+      ${rankExpression} AS score,
+      ${snippetExpr} AS snippet
+    FROM ${table}
+    WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.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);
-  const columns = nodeColumnList(nodes3);
+  const columns = chunkFQCQM3KG_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      1, ${chunkFQCQM3KG_cjs.sqlNull(params.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
     RETURNING *
@@ -1383,22 +1480,22 @@ function buildInsertNode(tables3, params, timestamp2) {
 function buildInsertNodeNoReturn(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes3);
+  const columns = chunkFQCQM3KG_cjs.nodeColumnList(nodes3);
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(params.validFrom)}, ${sqlNull(params.validTo)},
+      1, ${chunkFQCQM3KG_cjs.sqlNull(params.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(params.validTo)},
       ${timestamp2}, ${timestamp2}
     )
   `;
 }
 function buildInsertNodesBatch(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = nodeColumnList(nodes3);
+  const columns = chunkFQCQM3KG_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkFQCQM3KG_cjs.sqlNull(nodeParams.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1407,10 +1504,10 @@ function buildInsertNodesBatch(tables3, params, timestamp2) {
 }
 function buildInsertNodesBatchReturning(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
-  const columns = nodeColumnList(nodes3);
+  const columns = chunkFQCQM3KG_cjs.nodeColumnList(nodes3);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(nodeParams.validFrom)}, ${sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkFQCQM3KG_cjs.sqlNull(nodeParams.validFrom)}, ${chunkFQCQM3KG_cjs.sqlNull(nodeParams.validTo)}, ${timestamp2}, ${timestamp2})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes3} (${columns})
@@ -1444,19 +1541,19 @@ function buildUpdateNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${quotedColumn(nodes3.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
+    drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(nodes3.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(nodes3.updatedAt)} = ${timestamp2}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes3.version)} = ${quotedColumn(nodes3.version)} + 1`
+      drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(nodes3.version)} = ${chunkFQCQM3KG_cjs.quotedColumn(nodes3.version)} + 1`
     );
   }
   if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes3.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(nodes3.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes3.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkFQCQM3KG_cjs.quotedColumn(nodes3.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   if (params.clearDeleted) {
@@ -1483,7 +1580,7 @@ function buildDeleteNode(tables3, params, timestamp2) {
   const { nodes: nodes3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${nodes3}
-    SET ${quotedColumn(nodes3.deletedAt)} = ${timestamp2}
+    SET ${chunkFQCQM3KG_cjs.quotedColumn(nodes3.deletedAt)} = ${timestamp2}
     WHERE ${nodes3.graphId} = ${params.graphId}
       AND ${nodes3.kind} = ${params.kind}
       AND ${nodes3.id} = ${params.id}
@@ -1550,12 +1647,12 @@ function buildSetActiveSchema(tables3, graphId, version, dialect = "sqlite") {
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
+    SET ${chunkFQCQM3KG_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(false)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
     UPDATE ${schemaVersions3}
-    SET ${quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
+    SET ${chunkFQCQM3KG_cjs.quotedColumn(schemaVersions3.isActive)} = ${strategy.booleanLiteral(true)}
     WHERE ${schemaVersions3.graphId} = ${graphId}
       AND ${schemaVersions3.version} = ${version}
   `;
@@ -1573,22 +1670,22 @@ function buildInsertUniqueSqlite(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques3.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques3.nodeId)}
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} = CASE
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
+        ELSE ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)}
       END,
-      ${quotedColumn(uniques3.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques3.concreteKind)}
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.concreteKind)} = CASE
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
+        ELSE ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.concreteKind)}
       END,
-      ${quotedColumn(uniques3.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques3.deletedAt)}
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} = CASE
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
+        WHEN ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
+        ELSE ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)}
       END
-    RETURNING ${quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 function buildInsertUniquePostgres(tables3, params) {
@@ -1605,22 +1702,22 @@ function buildInsertUniquePostgres(tables3, params) {
     )
     ON CONFLICT (${conflictColumns})
     DO UPDATE SET
-      ${quotedColumn(uniques3.nodeId)} = CASE
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.nodeId}
         ELSE ${existingColumn(uniques3.nodeId)}
       END,
-      ${quotedColumn(uniques3.concreteKind)} = CASE
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.concreteKind)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
         ELSE ${existingColumn(uniques3.concreteKind)}
       END,
-      ${quotedColumn(uniques3.deletedAt)} = CASE
+      ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} = CASE
         WHEN ${existingColumn(uniques3.nodeId)} = ${params.nodeId} THEN NULL
         WHEN ${existingColumn(uniques3.deletedAt)} IS NOT NULL THEN NULL
         ELSE ${existingColumn(uniques3.deletedAt)}
       END
-    RETURNING ${quotedColumn(uniques3.nodeId)} as node_id
+    RETURNING ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.nodeId)} as node_id
   `;
 }
 var UNIQUE_INSERT_BUILDERS = {
@@ -1635,7 +1732,7 @@ function buildDeleteUnique(tables3, params, timestamp2) {
   const { uniques: uniques3 } = tables3;
   return drizzleOrm.sql`
     UPDATE ${uniques3}
-    SET ${quotedColumn(uniques3.deletedAt)} = ${timestamp2}
+    SET ${chunkFQCQM3KG_cjs.quotedColumn(uniques3.deletedAt)} = ${timestamp2}
     WHERE ${uniques3.graphId} = ${params.graphId}
       AND ${uniques3.nodeKind} = ${params.nodeKind}
       AND ${uniques3.constraintName} = ${params.constraintName}
@@ -1903,13 +2000,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);
     },
@@ -1927,11 +2038,15 @@ function createCommonOperationStrategy(tables3, dialect) {
     }
   };
 }
-function createSqliteOperationStrategy(tables3) {
-  return createCommonOperationStrategy(tables3, "sqlite");
+function createSqliteOperationStrategy(tables3, fulltextStrategy) {
+  return createCommonOperationStrategy(tables3, "sqlite", fulltextStrategy);
 }
-function createPostgresOperationStrategy(tables3) {
-  const common = createCommonOperationStrategy(tables3, "postgres");
+function createPostgresOperationStrategy(tables3, fulltextStrategy) {
+  const common = createCommonOperationStrategy(
+    tables3,
+    "postgres",
+    fulltextStrategy
+  );
   return {
     ...common,
     buildUpsertEmbedding(params, timestamp2) {
@@ -1989,11 +2104,11 @@ function generateVectorIndexName(graphId, nodeKind, fieldPath, metric = "cosine"
     metric
   ];
   const name = parts.join("_");
-  if (name.length <= chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+  if (name.length <= chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH) {
     return name;
   }
   const hash = shortHash(name);
-  const truncated = name.slice(0, chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length);
+  const truncated = name.slice(0, chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH - 1 - hash.length);
   return `${truncated}_${hash}`;
 }
 function getOperatorClass(metric) {
@@ -2172,5 +2287,5 @@ exports.tables2 = tables2;
 exports.uniques = uniques;
 exports.uniques2 = uniques2;
 exports.wrapWithManagedClose = wrapWithManagedClose;
-//# sourceMappingURL=chunk-IYWWXOVK.cjs.map
-//# sourceMappingURL=chunk-IYWWXOVK.cjs.map
+//# sourceMappingURL=chunk-Q73OWTJY.cjs.map
+//# sourceMappingURL=chunk-Q73OWTJY.cjs.map