@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/chunk-TOTPVGOG.cjs

@@ -1,774 +0,0 @@
-'use strict';
-
-var chunkUJLOZYKT_cjs = require('./chunk-UJLOZYKT.cjs');
-var chunkKGC4LY5T_cjs = require('./chunk-KGC4LY5T.cjs');
-var chunkHTGDWIDE_cjs = require('./chunk-HTGDWIDE.cjs');
-var chunkJJRCLAUN_cjs = require('./chunk-JJRCLAUN.cjs');
-var chunk2JXB3NYJ_cjs = require('./chunk-2JXB3NYJ.cjs');
-var chunkUNNPKQUG_cjs = require('./chunk-UNNPKQUG.cjs');
-var chunkRHZWOJVA_cjs = require('./chunk-RHZWOJVA.cjs');
-var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
-var drizzleOrm = require('drizzle-orm');
-var pgCore = require('drizzle-orm/pg-core');
-
-// src/backend/drizzle/execution/postgres-execution.ts
-function hasFunctionProperty(value, property) {
-  if (value === void 0 || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate[property] === "function";
-}
-function isPgNativeClient(candidate) {
-  return typeof candidate === "object" && hasFunctionProperty(candidate, "query");
-}
-function isPgliteClient(candidate) {
-  return typeof candidate === "object" && hasFunctionProperty(candidate, "query") && hasFunctionProperty(candidate, "dumpDataDir");
-}
-function isPostgresJsClient(candidate) {
-  return typeof candidate === "function" && hasFunctionProperty(candidate, "unsafe") && hasFunctionProperty(candidate, "begin");
-}
-function isNeonHttpClient(db) {
-  const candidate = db.$client;
-  return typeof candidate === "function" && hasFunctionProperty(candidate, "transaction") && !hasFunctionProperty(candidate, "begin");
-}
-var DEFAULT_POSTGRES_STATEMENT_CACHE_MAX = 256;
-var STATEMENT_NAME_CACHE = /* @__PURE__ */ new Map();
-var nextStatementId = 0;
-function statementNameFor(sqlText, cacheMax) {
-  return chunkUJLOZYKT_cjs.getOrCreateLru(STATEMENT_NAME_CACHE, sqlText, cacheMax, () => {
-    const name = `tg_${nextStatementId}`;
-    nextStatementId += 1;
-    return name;
-  });
-}
-function normalizeRow(row) {
-  if (row === null || typeof row !== "object") return row;
-  let mutated;
-  for (const key of Object.keys(row)) {
-    const value = row[key];
-    if (value instanceof Date) {
-      mutated ??= { ...row };
-      mutated[key] = value.toISOString();
-    }
-  }
-  return mutated ?? row;
-}
-function normalizeRows(rows) {
-  let mutated;
-  for (let index = 0; index < rows.length; index += 1) {
-    const original = rows[index];
-    const normalized = normalizeRow(original);
-    if (normalized !== original) {
-      mutated ??= [...rows];
-      mutated[index] = normalized;
-    }
-  }
-  return mutated ?? rows;
-}
-function wrapNodePgClient(client, cacheMax) {
-  return {
-    async query(sqlText, params) {
-      const result = await client.query({
-        name: statementNameFor(sqlText, cacheMax),
-        text: sqlText,
-        values: params
-      });
-      return { rows: normalizeRows(result.rows) };
-    }
-  };
-}
-function wrapNodePgClientUnnamed(client) {
-  return {
-    async query(sqlText, params) {
-      const result = await client.query(sqlText, params);
-      return { rows: normalizeRows(result.rows) };
-    }
-  };
-}
-function adaptPostgresJsClient(sql2) {
-  return {
-    async query(sqlText, params) {
-      const rows = await sql2.unsafe(sqlText, params);
-      return { rows };
-    }
-  };
-}
-function resolvePgClient(db, prepareStatements, cacheMax) {
-  if (isNeonHttpClient(db)) {
-    return void 0;
-  }
-  const client = db.$client;
-  if (isPgliteClient(client)) {
-    return wrapNodePgClientUnnamed(client);
-  }
-  if (isPgNativeClient(client)) {
-    return prepareStatements ? wrapNodePgClient(client, cacheMax) : wrapNodePgClientUnnamed(client);
-  }
-  if (isPostgresJsClient(client)) {
-    return adaptPostgresJsClient(client);
-  }
-  return void 0;
-}
-async function executeDrizzleQuery(db, query) {
-  const result = await db.execute(query);
-  if (Array.isArray(result)) {
-    return result;
-  }
-  return result.rows;
-}
-function createPgPreparedStatement(pgClient, sqlText) {
-  return {
-    async execute(params) {
-      const result = await pgClient.query(sqlText, params);
-      return result.rows;
-    }
-  };
-}
-function createPostgresExecutionAdapter(db, options = {}) {
-  const prepareStatements = options.prepareStatements ?? true;
-  const cacheMax = options.preparedStatementCacheMax ?? DEFAULT_POSTGRES_STATEMENT_CACHE_MAX;
-  const pgClient = resolvePgClient(db, prepareStatements, cacheMax);
-  function compile(query) {
-    return chunkUJLOZYKT_cjs.compileQueryWithDialect(db, query, "PostgreSQL");
-  }
-  if (pgClient === void 0) {
-    return {
-      compile,
-      async execute(query) {
-        return executeDrizzleQuery(db, query);
-      }
-    };
-  }
-  const pgQueryClient = pgClient;
-  async function executeCompiled(compiledQuery) {
-    const result = await pgQueryClient.query(
-      compiledQuery.sql,
-      compiledQuery.params
-    );
-    return result.rows;
-  }
-  return {
-    compile,
-    async execute(query) {
-      const compiled = compile(query);
-      return executeCompiled(compiled);
-    },
-    executeCompiled,
-    prepare(sqlText) {
-      return createPgPreparedStatement(pgQueryClient, sqlText);
-    }
-  };
-}
-
-// 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(chunkUNNPKQUG_cjs.POSTGRES_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT)
-);
-var POSTGRES_EDGE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(chunkUNNPKQUG_cjs.POSTGRES_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT)
-);
-var POSTGRES_GET_NODES_ID_CHUNK_SIZE = Math.max(
-  1,
-  chunkUNNPKQUG_cjs.POSTGRES_MAX_BIND_PARAMETERS - 2
-);
-var POSTGRES_GET_EDGES_ID_CHUNK_SIZE = Math.max(
-  1,
-  chunkUNNPKQUG_cjs.POSTGRES_MAX_BIND_PARAMETERS - 1
-);
-var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
-var POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
-  1,
-  chunkUNNPKQUG_cjs.POSTGRES_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
-);
-var toNodeRow = chunkJJRCLAUN_cjs.createNodeRowMapper(chunkJJRCLAUN_cjs.POSTGRES_ROW_MAPPER_CONFIG);
-var toEdgeRow = chunkJJRCLAUN_cjs.createEdgeRowMapper(chunkJJRCLAUN_cjs.POSTGRES_ROW_MAPPER_CONFIG);
-var toUniqueRow = chunkJJRCLAUN_cjs.createUniqueRowMapper(chunkJJRCLAUN_cjs.POSTGRES_ROW_MAPPER_CONFIG);
-var toSchemaVersionRow = chunkJJRCLAUN_cjs.createSchemaVersionRowMapper(
-  chunkJJRCLAUN_cjs.POSTGRES_ROW_MAPPER_CONFIG
-);
-function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
-  return {
-    ...chunkUNNPKQUG_cjs.POSTGRES_CAPABILITIES,
-    ...vectorStrategy === void 0 ? {} : { vector: chunk2JXB3NYJ_cjs.buildVectorCapabilities(vectorStrategy) },
-    fulltext: chunk2JXB3NYJ_cjs.buildFulltextCapabilities(fulltextStrategy)
-  };
-}
-function createPostgresBackend(db, options = {}) {
-  const tables2 = options.tables ?? chunkUJLOZYKT_cjs.tables;
-  const fulltextStrategy = options.fulltext ?? chunk2JXB3NYJ_cjs.tsvectorStrategy;
-  const vectorStrategy = options.vector === false ? void 0 : options.vector ?? chunkKGC4LY5T_cjs.pgvectorStrategy;
-  const vectorSlotLatch = vectorStrategy === void 0 ? void 0 : chunkUJLOZYKT_cjs.createVectorSlotLatch();
-  const baseCapabilities = buildPostgresCapabilities(
-    fulltextStrategy,
-    vectorStrategy
-  );
-  const httpOnlyOverrides = isNeonHttpClient(db) ? { transactions: false } : {};
-  const capabilities = {
-    ...baseCapabilities,
-    ...httpOnlyOverrides,
-    ...options.capabilities
-  };
-  const adapterOptions = {
-    ...options.prepareStatements === void 0 ? {} : { prepareStatements: options.prepareStatements },
-    ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax }
-  };
-  const executionAdapter = createPostgresExecutionAdapter(db, adapterOptions);
-  const tableNames = {
-    nodes: drizzleOrm.getTableName(tables2.nodes),
-    edges: drizzleOrm.getTableName(tables2.edges),
-    recordedNodes: drizzleOrm.getTableName(tables2.recordedNodes),
-    recordedEdges: drizzleOrm.getTableName(tables2.recordedEdges),
-    recordedClock: drizzleOrm.getTableName(tables2.recordedClock),
-    fulltext: tables2.fulltextTableName,
-    uniques: drizzleOrm.getTableName(tables2.uniques)
-  };
-  const coreAnalyzeStatement = drizzleOrm.sql`ANALYZE ${drizzleOrm.sql.join(
-    [
-      tableNames.nodes,
-      tableNames.edges,
-      drizzleOrm.getTableName(tables2.uniques),
-      tableNames.fulltext
-    ].map((name) => chunkHTGDWIDE_cjs.quoteIdentifier(name)),
-    drizzleOrm.sql`, `
-  )}`;
-  const recordedAnalyzeTables = [
-    tableNames.recordedNodes,
-    tableNames.recordedEdges,
-    tableNames.recordedClock
-  ];
-  const operationStrategy = chunkUJLOZYKT_cjs.createPostgresOperationStrategy(
-    tables2,
-    fulltextStrategy
-  );
-  const operations = createPostgresOperationBackend({
-    db,
-    executionAdapter,
-    adapterOptions,
-    operationStrategy,
-    tableNames,
-    capabilities,
-    fulltextStrategy,
-    vectorStrategy,
-    vectorSlotLatch
-  });
-  const recordedTableExists = chunkUJLOZYKT_cjs.createCachedTableExistence(
-    async (tableName) => {
-      const rows = await executionAdapter.execute(
-        operationStrategy.buildTableExists(tableName)
-      );
-      return rows[0];
-    },
-    { cacheExisting: false }
-  );
-  function runSchemaWriteTransaction(graphId, fn) {
-    if (!capabilities.transactions) {
-      throw new chunkJIEJCTDS_cjs.ConfigurationError(
-        "commitSchemaVersion and setActiveVersion require atomic transactions, but this Postgres backend does not provide them. The drizzle-orm/neon-http driver communicates over HTTP and cannot hold a session across statements; use drizzle-orm/neon-serverless (websocket) for transactional writes.",
-        {
-          backend: "postgres",
-          capability: "transactions",
-          supportsTransactions: false
-        }
-      );
-    }
-    return db.transaction(async (tx) => {
-      await tx.execute(drizzleOrm.sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);
-      const txBackend = createTransactionBackend({
-        db: tx,
-        adapterOptions,
-        operationStrategy,
-        tableNames,
-        capabilities,
-        fulltextStrategy,
-        vectorStrategy});
-      return fn(txBackend);
-    });
-  }
-  const matTable = tables2.contributionMaterializations;
-  async function ensureContributionMaterializationsTableImpl() {
-    await db.execute(drizzleOrm.sql.raw(chunkUJLOZYKT_cjs.generatePgCreateTableSQL(matTable)));
-  }
-  async function getContributionMaterializationRow(identity) {
-    const rows = await db.select().from(matTable).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(matTable.graphId, identity.graphId),
-        drizzleOrm.eq(matTable.logicalName, identity.logicalName),
-        drizzleOrm.eq(matTable.owner, identity.owner),
-        drizzleOrm.eq(matTable.tableName, identity.tableName)
-      )
-    );
-    const row = rows[0];
-    if (row === void 0) return void 0;
-    return chunkUJLOZYKT_cjs.mapContributionMaterializationRow(
-      row,
-      chunkUJLOZYKT_cjs.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode
-    );
-  }
-  async function recordContributionMaterializationRow(params) {
-    await db.insert(matTable).values(
-      chunkUJLOZYKT_cjs.buildContributionInsertValues(
-        params,
-        chunkUJLOZYKT_cjs.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.encode
-      )
-    ).onConflictDoUpdate({
-      target: [
-        matTable.graphId,
-        matTable.logicalName,
-        matTable.owner,
-        matTable.tableName
-      ],
-      set: chunkUJLOZYKT_cjs.buildContributionOnConflictSet(
-        matTable.materializedAt,
-        params.materializedAt
-      )
-    });
-  }
-  const contributionMaterializer = chunkUJLOZYKT_cjs.createContributionMaterializer({
-    dialect: "postgres",
-    fulltextStrategy,
-    fulltextTableName: tables2.fulltextTableName,
-    execDdl: async (statement) => {
-      await db.execute(drizzleOrm.sql.raw(statement));
-    },
-    ensureMarkerTable: ensureContributionMaterializationsTableImpl,
-    getMarker: getContributionMaterializationRow,
-    recordMarker: recordContributionMaterializationRow
-  });
-  function bindTransactionBackend(tx) {
-    const txBackend = createTransactionBackend({
-      db: tx,
-      adapterOptions,
-      operationStrategy,
-      tableNames,
-      capabilities,
-      fulltextStrategy,
-      vectorStrategy});
-    return chunkUJLOZYKT_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
-  }
-  const backend = {
-    ...operations,
-    async bootstrapTables() {
-      const statements = chunkUJLOZYKT_cjs.generatePostgresDDL(tables2, fulltextStrategy);
-      for (const statement of statements) {
-        await db.execute(drizzleOrm.sql.raw(statement));
-      }
-    },
-    // Every fulltext-touching method asserts the durable marker instead
-    // of lazily emitting DDL. Steady state performs zero ensure; an
-    // uninitialized database throws `StoreNotInitializedError` loudly
-    // rather than self-healing on a read/write path (#135). Shared
-    // verbatim with the tx-scoped gate via `gateFulltextMethods`.
-    ...chunkUJLOZYKT_cjs.gateFulltextMethods(
-      operations,
-      contributionMaterializer.assertInitialized
-    ),
-    async executeDdl(ddl) {
-      await db.execute(drizzleOrm.sql.raw(ddl));
-    },
-    async ensureIndexMaterializationsTable() {
-      await db.execute(
-        drizzleOrm.sql.raw(chunkUJLOZYKT_cjs.generatePgCreateTableSQL(tables2.indexMaterializations))
-      );
-    },
-    async getIndexMaterialization(indexName) {
-      const t = tables2.indexMaterializations;
-      const rows = await db.select().from(t).where(drizzleOrm.eq(t.indexName, indexName));
-      const row = rows[0];
-      if (row === void 0) return void 0;
-      return chunkUJLOZYKT_cjs.mapMaterializationRow(row, chunkUJLOZYKT_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.decode);
-    },
-    async getIndexMaterializations(statusKeys) {
-      if (statusKeys.length === 0) return [];
-      const t = tables2.indexMaterializations;
-      const rows = await db.select().from(t).where(drizzleOrm.inArray(t.indexName, [...statusKeys]));
-      return rows.map(
-        (row) => chunkUJLOZYKT_cjs.mapMaterializationRow(row, chunkUJLOZYKT_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.decode)
-      );
-    },
-    async recordIndexMaterialization(params) {
-      const t = tables2.indexMaterializations;
-      await db.insert(t).values(
-        chunkUJLOZYKT_cjs.buildMaterializationInsertValues(
-          params,
-          chunkUJLOZYKT_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.encode
-        )
-      ).onConflictDoUpdate({
-        target: t.indexName,
-        set: chunkUJLOZYKT_cjs.buildMaterializationOnConflictSet(
-          t.materializedAt,
-          params.materializedAt
-        )
-      });
-    },
-    async ensureContributionMaterializationsTable() {
-      await ensureContributionMaterializationsTableImpl();
-    },
-    async getContributionMaterialization(identity) {
-      return getContributionMaterializationRow(identity);
-    },
-    async recordContributionMaterialization(params) {
-      await recordContributionMaterializationRow(params);
-    },
-    async assertRuntimeContributionsInitialized(graphId) {
-      await contributionMaterializer.assertInitialized(graphId);
-    },
-    async ensureKindRemovalsTable() {
-      await db.execute(drizzleOrm.sql.raw(chunkUJLOZYKT_cjs.generatePgCreateTableSQL(tables2.kindRemovals)));
-    },
-    async getPendingKindRemovals(graphId) {
-      const t = tables2.kindRemovals;
-      const rows = await db.select().from(t).where(drizzleOrm.and(drizzleOrm.eq(t.graphId, graphId), drizzleOrm.isNull(t.removedAt)));
-      return rows.map(
-        (row) => chunkUJLOZYKT_cjs.mapKindRemovalRow(row, chunkUJLOZYKT_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
-      );
-    },
-    async getAllKindRemovals(graphId) {
-      const t = tables2.kindRemovals;
-      const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
-      return rows.map(
-        (row) => chunkUJLOZYKT_cjs.mapKindRemovalRow(row, chunkUJLOZYKT_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
-      );
-    },
-    async recordKindRemoval(params) {
-      const t = tables2.kindRemovals;
-      await db.insert(t).values(
-        chunkUJLOZYKT_cjs.buildKindRemovalInsertValues(
-          params,
-          chunkUJLOZYKT_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.encode
-        )
-      ).onConflictDoUpdate({
-        target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
-        set: chunkUJLOZYKT_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
-      });
-    },
-    async ensureReconciliationMarkersTable() {
-      await db.execute(
-        drizzleOrm.sql.raw(chunkUJLOZYKT_cjs.generatePgCreateTableSQL(tables2.reconciliationMarkers))
-      );
-    },
-    async ensureRuntimeContributions(graphId) {
-      await contributionMaterializer.ensureRuntimeContributions(graphId);
-    },
-    /**
-     * Superseded by `ensureRuntimeContributions(graphId)` (#129).
-     * Retained as a thin back-compat wrapper for callers predating
-     * #129; #135 routed it through the durable-marker writer.
-     */
-    async ensureFulltextTable(graphId) {
-      await contributionMaterializer.ensureRuntimeContributions(graphId);
-    },
-    async getReconciliationMarker(graphId) {
-      const t = tables2.reconciliationMarkers;
-      const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
-      return rows[0]?.reconciledToVersion;
-    },
-    async setReconciliationMarker(graphId, version) {
-      const t = tables2.reconciliationMarkers;
-      await db.insert(t).values({ graphId, reconciledToVersion: version }).onConflictDoUpdate({
-        target: t.graphId,
-        set: { reconciledToVersion: version }
-      });
-    },
-    async refreshStatistics() {
-      await db.execute(coreAnalyzeStatement);
-      const tablePresence = await Promise.all(
-        recordedAnalyzeTables.map(async (tableName) => ({
-          tableName,
-          exists: await recordedTableExists(tableName)
-        }))
-      );
-      const presentRecordedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
-      if (presentRecordedTables.length > 0) {
-        await db.execute(
-          drizzleOrm.sql`ANALYZE ${drizzleOrm.sql.join(
-            presentRecordedTables.map((name) => chunkHTGDWIDE_cjs.quoteIdentifier(name)),
-            drizzleOrm.sql`, `
-          )}`
-        );
-      }
-    },
-    async commitSchemaVersion(params) {
-      return runSchemaWriteTransaction(
-        params.graphId,
-        (target) => target.commitSchemaVersion(params)
-      );
-    },
-    async setActiveVersion(params) {
-      await runSchemaWriteTransaction(
-        params.graphId,
-        (target) => target.setActiveVersion(params)
-      );
-    },
-    async transaction(fn, options2) {
-      const txConfig = options2?.isolationLevel ? {
-        isolationLevel: options2.isolationLevel.replace("_", " ")
-      } : void 0;
-      return db.transaction(
-        async (tx) => fn(bindTransactionBackend(tx), tx),
-        txConfig
-      );
-    },
-    adoptTransaction(externalTx) {
-      if (!capabilities.transactions) {
-        throw new chunkJIEJCTDS_cjs.ConfigurationError(
-          "Cross-store atomicity is unavailable on this Postgres backend: its driver does not support transactions (drizzle-orm/neon-http, Cloudflare D1). Adopting an external transaction here would let the caller's relational write commit with no way to roll back the graph write. Use a node-postgres or neon-serverless (Pool/WebSocket) connection for cross-store transactions.",
-          {
-            backend: "postgres",
-            capability: "transactions",
-            supportsTransactions: false
-          }
-        );
-      }
-      chunkUJLOZYKT_cjs.assertAdoptedDialect(externalTx, pgCore.PgDatabase, "postgres");
-      return bindTransactionBackend(externalTx);
-    },
-    async close() {
-    }
-  };
-  return backend;
-}
-function createPostgresOperationBackend(options) {
-  const {
-    db,
-    executionAdapter,
-    adapterOptions,
-    operationStrategy,
-    tableNames,
-    capabilities,
-    fulltextStrategy,
-    vectorStrategy,
-    vectorSlotLatch
-  } = options;
-  async function execAll(query) {
-    return executionAdapter.execute(query);
-  }
-  async function execGet(query) {
-    const rows = await executionAdapter.execute(query);
-    return rows[0];
-  }
-  async function execRun(query) {
-    await executionAdapter.execute(query);
-  }
-  let efSearchUnsupportedWarned = false;
-  function warnEfSearchUnsupported() {
-    if (efSearchUnsupportedWarned) return;
-    efSearchUnsupportedWarned = true;
-    if (typeof console === "undefined" || typeof console.warn !== "function") {
-      return;
-    }
-    console.warn(
-      "[typegraph] efSearch (hnsw.ef_search override) was ignored: this Postgres backend has transactions disabled (e.g. drizzle-orm/neon-http), and SET LOCAL needs a transaction to scope the override. Use a transactional driver (node-postgres / neon-serverless / postgres-js) to apply efSearch."
-    );
-  }
-  async function runVectorSearch(efSearch, query) {
-    if (efSearch === void 0) {
-      return execAll(query);
-    }
-    if (!capabilities.transactions) {
-      warnEfSearchUnsupported();
-      return execAll(query);
-    }
-    const setEfSearch = drizzleOrm.sql.raw(`SET LOCAL hnsw.ef_search = ${efSearch}`);
-    if (db instanceof pgCore.PgTransaction) {
-      const [setting] = await execAll(
-        drizzleOrm.sql`SELECT current_setting('hnsw.ef_search') AS ef_search`
-      );
-      await execRun(setEfSearch);
-      const rows = await execAll(query);
-      if (setting !== void 0) {
-        await execRun(
-          drizzleOrm.sql`SELECT set_config('hnsw.ef_search', ${setting.ef_search}, true)`
-        );
-      }
-      return rows;
-    }
-    return db.transaction(async (tx) => {
-      const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);
-      await txAdapter.execute(setEfSearch);
-      return txAdapter.execute(query);
-    });
-  }
-  async function ensureVectorSlotStorage(slot) {
-    if (vectorStrategy === void 0 || vectorSlotLatch === void 0) return;
-    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {
-      await execRun(drizzleOrm.sql.raw(statement));
-    });
-  }
-  const commonBackend = chunkUJLOZYKT_cjs.createCommonOperationBackend({
-    batchConfig: {
-      checkUniqueBatchChunkSize: POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
-      edgeInsertBatchSize: POSTGRES_EDGE_INSERT_BATCH_SIZE,
-      getEdgesChunkSize: POSTGRES_GET_EDGES_ID_CHUNK_SIZE,
-      getNodesChunkSize: POSTGRES_GET_NODES_ID_CHUNK_SIZE,
-      nodeInsertBatchSize: POSTGRES_NODE_INSERT_BATCH_SIZE
-    },
-    execution: {
-      execAll,
-      execGet,
-      execRun
-    },
-    nowIso: chunkJJRCLAUN_cjs.nowIso,
-    operationStrategy,
-    rowMappers: {
-      toEdgeRow,
-      toNodeRow,
-      toSchemaVersionRow,
-      toUniqueRow
-    },
-    tableExistenceCache: { cacheExisting: false }
-  });
-  const executeCompiled = executionAdapter.executeCompiled;
-  const executeRawMethod = executeCompiled === void 0 ? {} : {
-    async executeRaw(sqlText, params) {
-      return executeCompiled({ params, sql: sqlText });
-    }
-  };
-  const vectorEmbeddingMethods = vectorStrategy === void 0 ? {} : {
-    async upsertEmbedding(params) {
-      const slot = chunkUJLOZYKT_cjs.vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
-      const statements = vectorStrategy.buildUpsert(slot, params, chunkJJRCLAUN_cjs.nowIso());
-      try {
-        for (const statement of statements) {
-          await execRun(statement);
-        }
-      } catch (error) {
-        throw chunkUJLOZYKT_cjs.mapVectorWriteError(error, params);
-      }
-    },
-    async deleteEmbedding(params) {
-      const slot = chunkUJLOZYKT_cjs.vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
-      const statements = vectorStrategy.buildDelete(slot, params);
-      for (const statement of statements) {
-        await execRun(statement);
-      }
-    },
-    async vectorSearch(params) {
-      chunk2JXB3NYJ_cjs.assertVectorSearchLimit(params.limit);
-      chunkKGC4LY5T_cjs.assertPgvectorEfSearch(params.efSearch);
-      const slot = chunkUJLOZYKT_cjs.vectorSlotFromParams(params);
-      await ensureVectorSlotStorage(slot);
-      const query = vectorStrategy.buildSearch(slot, params);
-      let rows;
-      try {
-        rows = await runVectorSearch(params.efSearch, query);
-      } catch (error) {
-        throw chunkUJLOZYKT_cjs.mapVectorWriteError(error, params);
-      }
-      return rows.map((row) => ({
-        nodeId: row.node_id,
-        score: row.score
-      }));
-    }
-  };
-  const operationBackend = {
-    ...commonBackend,
-    ...executeRawMethod,
-    ...vectorEmbeddingMethods,
-    capabilities,
-    fulltextStrategy,
-    ...vectorStrategy === void 0 ? {} : { vectorStrategy },
-    dialect: "postgres",
-    tableNames,
-    // === Vector Index Operations ===
-    async createVectorIndex(params) {
-      if (vectorStrategy === void 0) return;
-      const slot = chunkUJLOZYKT_cjs.vectorSlotFromCreateIndexParams(params);
-      await ensureVectorSlotStorage(slot);
-      const indexStatement = vectorStrategy.buildCreateIndex?.(slot, {
-        concurrent: params.concurrent === true
-      });
-      if (indexStatement !== void 0) {
-        await execRun(indexStatement);
-      }
-    },
-    // === Fulltext Operations ===
-    async upsertFulltext(params) {
-      const timestamp = chunkJJRCLAUN_cjs.nowIso();
-      const statements = operationStrategy.buildUpsertFulltext(
-        params,
-        timestamp
-      );
-      for (const stmt of statements) {
-        await execRun(stmt);
-      }
-    },
-    async deleteFulltext(params) {
-      const statements = operationStrategy.buildDeleteFulltext(params);
-      for (const stmt of statements) {
-        await execRun(stmt);
-      }
-    },
-    async upsertFulltextBatch(params) {
-      if (params.rows.length === 0) return;
-      const timestamp = chunkJJRCLAUN_cjs.nowIso();
-      const statements = operationStrategy.buildUpsertFulltextBatch(
-        params,
-        timestamp
-      );
-      for (const stmt of statements) {
-        await execRun(stmt);
-      }
-    },
-    async deleteFulltextBatch(params) {
-      if (params.nodeIds.length === 0) return;
-      const statements = operationStrategy.buildDeleteFulltextBatch(params);
-      for (const stmt of statements) {
-        await execRun(stmt);
-      }
-    },
-    async fulltextSearch(params) {
-      const query = operationStrategy.buildFulltextSearch(params);
-      const rows = await execAll(query);
-      return rows.map((row, index) => ({
-        nodeId: row.node_id,
-        score: chunkJJRCLAUN_cjs.coerceNumericScore(row.score),
-        rank: index + 1,
-        ...row.snippet === null ? {} : { snippet: row.snippet }
-      }));
-    },
-    async dropVectorIndex(params) {
-      if (vectorStrategy === void 0) return;
-      const slot = chunkUJLOZYKT_cjs.vectorSlotFromDropIndexParams(params);
-      const dropStatement = vectorStrategy.buildDropIndex?.(slot);
-      if (dropStatement === void 0) return;
-      try {
-        await execRun(dropStatement);
-      } catch (error) {
-        if (!chunkRHZWOJVA_cjs.isMissingTableError(error)) throw error;
-      }
-    },
-    // === Query Execution ===
-    async execute(query) {
-      return executionAdapter.execute(query);
-    },
-    compileSql(query) {
-      return executionAdapter.compile(query);
-    }
-  };
-  return operationBackend;
-}
-function createTransactionBackend(options) {
-  const txExecutionAdapter = options.executionAdapter ?? createPostgresExecutionAdapter(options.db, options.adapterOptions);
-  return createPostgresOperationBackend({
-    db: options.db,
-    executionAdapter: txExecutionAdapter,
-    adapterOptions: options.adapterOptions,
-    operationStrategy: options.operationStrategy,
-    tableNames: options.tableNames,
-    capabilities: options.capabilities,
-    fulltextStrategy: options.fulltextStrategy,
-    vectorStrategy: options.vectorStrategy,
-    vectorSlotLatch: options.vectorStrategy === void 0 ? void 0 : chunkUJLOZYKT_cjs.createVectorSlotLatch()
-  });
-}
-
-exports.createPostgresBackend = createPostgresBackend;
-//# sourceMappingURL=chunk-TOTPVGOG.cjs.map
-//# sourceMappingURL=chunk-TOTPVGOG.cjs.map