@nicia-ai/typegraph 0.42.0 → 0.42.1

package/dist/{chunk-BGXKXGDI.js → chunk-YPVQYM3L.js}

@@ -1,10 +1,10 @@
-import { createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, EMBEDDING_UPSERT_PARAM_COUNT, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, gateFulltext, getOrCreateLru } from './chunk-HHBKGPEI.js';
+import { createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru } from './chunk-HHBKGPEI.js';
 import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-ZGOUVMVS.js';
 import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-CVNGKTHO.js';
 import { tables, generatePgCreateTableSQL, generatePostgresDDL } from './chunk-Z3WIL6S3.js';
 import { toDrizzleSql, compileQueryWithDialect } from './chunk-UJRWOV5B.js';
 import { chunk } from './chunk-35S6P5ZU.js';
-import { normalizeGraphAnalyticsCapabilities, createBackendOverlay, POSTGRES_MAX_BIND_PARAMETERS, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-UZLEQFTV.js';
+import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-UZLEQFTV.js';
 import { isMissingTableError, isInsufficientResourcesError } from './chunk-CUPJL6TS.js';
 import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-42XYPKZU.js';
 import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-M4GYQF2H.js';
@@ -27,6 +27,10 @@ function isPgNativeClient(candidate) {
 function isPgliteClient(candidate) {
   return typeof candidate === "object" && hasFunctionProperty(candidate, "query") && hasFunctionProperty(candidate, "dumpDataDir");
 }
+var PGLITE_MAX_BIND_PARAMETERS = 32767;
+function isPgliteDatabase(db) {
+  return isPgliteClient(db.$client);
+}
 function transactionSession(carrier) {
   return carrier.session ?? carrier._?.session;
 }
@@ -138,9 +142,10 @@ async function executeDrizzleQuery(db, query) {
   }
   return result.rows;
 }
-function createPgPreparedStatement(pgClient, sqlText) {
+function createPgPreparedStatement(pgClient, sqlText, maxBindParameters) {
   return {
     async execute(params) {
+      assertWithinBindParameterLimit(params.length, maxBindParameters);
       const result = await pgClient.query(sqlText, params);
       return result.rows;
     }
@@ -149,6 +154,7 @@ function createPgPreparedStatement(pgClient, sqlText) {
 function createPostgresExecutionAdapter(db, options = {}) {
   const prepareStatements = options.prepareStatements ?? true;
   const cacheMax = options.preparedStatementCacheMax ?? DEFAULT_POSTGRES_STATEMENT_CACHE_MAX;
+  const maxBindParameters = options.maxBindParameters;
   const pgClient = resolvePgClient(
     db,
     prepareStatements,
@@ -158,10 +164,17 @@ function createPostgresExecutionAdapter(db, options = {}) {
   function compile(query) {
     return compileQueryWithDialect(db, query, "PostgreSQL");
   }
+  function assertCompiledWithinBindParameterLimit(compiledQuery) {
+    assertWithinBindParameterLimit(
+      compiledQuery.params.length,
+      maxBindParameters
+    );
+  }
   if (pgClient === void 0) {
     return {
       compile,
       async execute(query) {
+        assertCompiledWithinBindParameterLimit(compile(query));
         return executeDrizzleQuery(
           db,
           isSqlFragment(query) ? toDrizzleSql(query, "postgres") : query
@@ -171,6 +184,7 @@ function createPostgresExecutionAdapter(db, options = {}) {
   }
   const pgQueryClient = pgClient;
   async function executeCompiled(compiledQuery) {
+    assertCompiledWithinBindParameterLimit(compiledQuery);
     const result = await pgQueryClient.query(
       compiledQuery.sql,
       compiledQuery.params
@@ -181,6 +195,7 @@ function createPostgresExecutionAdapter(db, options = {}) {
     compile,
     async execute(query) {
       const compiled = compile(query);
+      assertCompiledWithinBindParameterLimit(compiled);
       if (isSqlFragment(query) && shouldForceCustomPlan(query)) {
         const result = await pgQueryClient.queryUnnamed(
           compiled.sql,
@@ -192,10 +207,30 @@ function createPostgresExecutionAdapter(db, options = {}) {
     },
     executeCompiled,
     prepare(sqlText) {
-      return createPgPreparedStatement(pgQueryClient, sqlText);
+      return createPgPreparedStatement(
+        pgQueryClient,
+        sqlText,
+        maxBindParameters
+      );
     }
   };
 }
+function assertWithinBindParameterLimit(parameterCount, maxBindParameters) {
+  if (maxBindParameters === void 0 || parameterCount <= maxBindParameters) {
+    return;
+  }
+  throw new ConfigurationError(
+    `PostgreSQL statement uses ${parameterCount} bound parameters, exceeding this backend's limit of ${maxBindParameters}.`,
+    {
+      capability: "maxBindParameters",
+      maxBindParameters,
+      parameterCount
+    },
+    {
+      suggestion: "Split the operation into smaller batches or lower the batch size before retrying."
+    }
+  );
+}
 
 // src/backend/drizzle/execution/statement-queue.ts
 function ignoreOutcome() {
@@ -251,42 +286,52 @@ function createSerialExecutionAdapter(adapter) {
 // src/backend/drizzle/postgres.ts
 var NODE_INSERT_PARAM_COUNT = 9;
 var EDGE_INSERT_PARAM_COUNT = 12;
-var POSTGRES_NODE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT)
-);
-var POSTGRES_EDGE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT)
-);
-var POSTGRES_GET_NODES_ID_CHUNK_SIZE = Math.max(
-  1,
-  POSTGRES_MAX_BIND_PARAMETERS - 2
-);
-var POSTGRES_GET_EDGES_ID_CHUNK_SIZE = Math.max(
-  1,
-  POSTGRES_MAX_BIND_PARAMETERS - 1
-);
+var GET_NODES_FIXED_PARAM_COUNT = 2;
+var GET_EDGES_FIXED_PARAM_COUNT = 1;
 var FULLTEXT_UPSERT_PARAM_COUNT = 6;
 var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
-var POSTGRES_FULLTEXT_UPSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / FULLTEXT_UPSERT_PARAM_COUNT)
-);
-var POSTGRES_FULLTEXT_DELETE_CHUNK_SIZE = Math.max(
-  1,
-  POSTGRES_MAX_BIND_PARAMETERS - FULLTEXT_DELETE_FIXED_PARAM_COUNT
-);
 var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
-var POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
-  1,
-  POSTGRES_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
-);
 var UNIQUE_INSERT_PARAM_COUNT = 6;
-var POSTGRES_UNIQUE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / UNIQUE_INSERT_PARAM_COUNT)
-);
+function computePostgresBatchChunkSizes(maxBindParameters) {
+  return {
+    checkUniqueBatchChunkSize: Math.max(
+      1,
+      maxBindParameters - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
+    ),
+    edgeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EDGE_INSERT_PARAM_COUNT)
+    ),
+    embeddingUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EMBEDDING_UPSERT_PARAM_COUNT)
+    ),
+    fulltextDeleteChunkSize: Math.max(
+      1,
+      maxBindParameters - FULLTEXT_DELETE_FIXED_PARAM_COUNT
+    ),
+    fulltextUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / FULLTEXT_UPSERT_PARAM_COUNT)
+    ),
+    getEdgesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_EDGES_FIXED_PARAM_COUNT
+    ),
+    getNodesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_NODES_FIXED_PARAM_COUNT
+    ),
+    nodeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT)
+    ),
+    uniqueInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT)
+    )
+  };
+}
 var toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
@@ -316,14 +361,23 @@ function createPostgresBackend(db, options = {}) {
       supported: false
     }
   } : {};
+  const configuredMaxBindParameters = options.capabilities?.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS;
+  const driverBindParameterOverrides = isPgliteDatabase(db) ? {
+    maxBindParameters: Math.min(
+      configuredMaxBindParameters,
+      PGLITE_MAX_BIND_PARAMETERS
+    )
+  } : {};
   const capabilities = normalizeGraphAnalyticsCapabilities({
     ...baseCapabilities,
     ...httpOnlyOverrides,
-    ...options.capabilities
+    ...options.capabilities,
+    ...driverBindParameterOverrides
   });
   const adapterOptions = {
     ...options.prepareStatements === void 0 ? {} : { prepareStatements: options.prepareStatements },
-    ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax }
+    ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax },
+    maxBindParameters: capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS
   };
   const executionAdapter = createPostgresExecutionAdapter(db, adapterOptions);
   const tableNames = {
@@ -946,23 +1000,9 @@ function createPostgresOperationBackend(options) {
       return txAdapter.execute(query);
     });
   }
-  const batchConfig = {
-    checkUniqueBatchChunkSize: POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
-    edgeInsertBatchSize: POSTGRES_EDGE_INSERT_BATCH_SIZE,
-    // Unlike the static siblings, the embedding upsert honors a runtime
-    // `maxBindParameters` override so its chunk size tracks the connection's
-    // actual bind budget.
-    embeddingUpsertBatchSize: Math.max(
-      1,
-      Math.floor(
-        (capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS) / EMBEDDING_UPSERT_PARAM_COUNT
-      )
-    ),
-    getEdgesChunkSize: POSTGRES_GET_EDGES_ID_CHUNK_SIZE,
-    getNodesChunkSize: POSTGRES_GET_NODES_ID_CHUNK_SIZE,
-    nodeInsertBatchSize: POSTGRES_NODE_INSERT_BATCH_SIZE,
-    uniqueInsertBatchSize: POSTGRES_UNIQUE_INSERT_BATCH_SIZE
-  };
+  const batchConfig = computePostgresBatchChunkSizes(
+    capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS
+  );
   const commonBackend = createCommonOperationBackend({
     batchConfig,
     execution: {
@@ -1205,7 +1245,7 @@ function createPostgresOperationBackend(options) {
       const timestamp = nowIso();
       for (const rows of chunk(
         params.rows,
-        POSTGRES_FULLTEXT_UPSERT_BATCH_SIZE
+        batchConfig.fulltextUpsertBatchSize
       )) {
         const statements = operationStrategy.buildUpsertFulltextBatch(
           { ...params, rows },
@@ -1220,7 +1260,7 @@ function createPostgresOperationBackend(options) {
       if (params.nodeIds.length === 0) return;
       for (const nodeIds of chunk(
         params.nodeIds,
-        POSTGRES_FULLTEXT_DELETE_CHUNK_SIZE
+        batchConfig.fulltextDeleteChunkSize
       )) {
         const statements = operationStrategy.buildDeleteFulltextBatch({
           ...params,
@@ -1293,5 +1333,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-BGXKXGDI.js.map
-//# sourceMappingURL=chunk-BGXKXGDI.js.map
+//# sourceMappingURL=chunk-YPVQYM3L.js.map
+//# sourceMappingURL=chunk-YPVQYM3L.js.map