@nicia-ai/typegraph 0.28.1 → 0.30.0

package/dist/chunk-K5VREXMZ.js

@@ -0,0 +1,738 @@
+import { pgvectorStrategy, quoteIdentifier, assertPgvectorEfSearch } from './chunk-FVIGJTS7.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, tables, createVectorSlotLatch, createPostgresOperationStrategy, createContributionMaterializer, gateFulltextMethods, createCommonOperationBackend, nowIso, generatePgCreateTableSQL, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generatePostgresDDL, vectorSlotFromParams, mapVectorWriteError, vectorSlotFromDropIndexParams, coerceNumericScore, vectorSlotFromCreateIndexParams, gateFulltext, compileQueryWithDialect, getOrCreateLru } from './chunk-N2OEOGBB.js';
+import { POSTGRES_CAPABILITIES } from './chunk-633N7DSE.js';
+import { isMissingTableError } from './chunk-M6OC455F.js';
+import { tsvectorStrategy, buildFulltextCapabilities, buildVectorCapabilities, assertVectorSearchLimit } from './chunk-AI3RNREM.js';
+import { ConfigurationError } from './chunk-TQOYM4LN.js';
+import { getTableName, sql, and, eq, isNull, inArray } from 'drizzle-orm';
+import { PgDatabase, PgTransaction } from '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 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 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 POSTGRES_MAX_BIND_PARAMETERS = 65535;
+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 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 toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
+var toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
+var toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
+var toSchemaVersionRow = createSchemaVersionRowMapper(
+  POSTGRES_ROW_MAPPER_CONFIG
+);
+function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
+  return {
+    ...POSTGRES_CAPABILITIES,
+    ...vectorStrategy === void 0 ? {} : { vector: buildVectorCapabilities(vectorStrategy) },
+    fulltext: buildFulltextCapabilities(fulltextStrategy)
+  };
+}
+function createPostgresBackend(db, options = {}) {
+  const tables2 = options.tables ?? tables;
+  const fulltextStrategy = options.fulltext ?? tsvectorStrategy;
+  const vectorStrategy = options.vector === false ? void 0 : options.vector ?? pgvectorStrategy;
+  const vectorSlotLatch = vectorStrategy === void 0 ? void 0 : 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: getTableName(tables2.nodes),
+    edges: getTableName(tables2.edges),
+    fulltext: tables2.fulltextTableName,
+    uniques: getTableName(tables2.uniques)
+  };
+  const analyzeStatement = sql`ANALYZE ${sql.join(
+    [
+      tableNames.nodes,
+      tableNames.edges,
+      getTableName(tables2.uniques),
+      tableNames.fulltext
+    ].map((name) => quoteIdentifier(name)),
+    sql`, `
+  )}`;
+  const operationStrategy = createPostgresOperationStrategy(
+    tables2,
+    fulltextStrategy
+  );
+  const operations = createPostgresOperationBackend({
+    db,
+    executionAdapter,
+    adapterOptions,
+    operationStrategy,
+    tableNames,
+    capabilities,
+    fulltextStrategy,
+    vectorStrategy,
+    vectorSlotLatch
+  });
+  function runSchemaWriteTransaction(graphId, fn) {
+    if (!capabilities.transactions) {
+      throw new 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(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(sql.raw(generatePgCreateTableSQL(matTable)));
+  }
+  async function getContributionMaterializationRow(identity) {
+    const rows = await db.select().from(matTable).where(
+      and(
+        eq(matTable.graphId, identity.graphId),
+        eq(matTable.logicalName, identity.logicalName),
+        eq(matTable.owner, identity.owner),
+        eq(matTable.tableName, identity.tableName)
+      )
+    );
+    const row = rows[0];
+    if (row === void 0) return void 0;
+    return mapContributionMaterializationRow(
+      row,
+      POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode
+    );
+  }
+  async function recordContributionMaterializationRow(params) {
+    await db.insert(matTable).values(
+      buildContributionInsertValues(
+        params,
+        POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.encode
+      )
+    ).onConflictDoUpdate({
+      target: [
+        matTable.graphId,
+        matTable.logicalName,
+        matTable.owner,
+        matTable.tableName
+      ],
+      set: buildContributionOnConflictSet(
+        matTable.materializedAt,
+        params.materializedAt
+      )
+    });
+  }
+  const contributionMaterializer = createContributionMaterializer({
+    dialect: "postgres",
+    fulltextStrategy,
+    fulltextTableName: tables2.fulltextTableName,
+    execDdl: async (statement) => {
+      await db.execute(sql.raw(statement));
+    },
+    ensureMarkerTable: ensureContributionMaterializationsTableImpl,
+    getMarker: getContributionMaterializationRow,
+    recordMarker: recordContributionMaterializationRow
+  });
+  function bindTransactionBackend(tx) {
+    const txBackend = createTransactionBackend({
+      db: tx,
+      adapterOptions,
+      operationStrategy,
+      tableNames,
+      capabilities,
+      fulltextStrategy,
+      vectorStrategy});
+    return gateFulltext(txBackend, contributionMaterializer.assertInitialized);
+  }
+  const backend = {
+    ...operations,
+    async bootstrapTables() {
+      const statements = generatePostgresDDL(tables2, fulltextStrategy);
+      for (const statement of statements) {
+        await db.execute(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`.
+    ...gateFulltextMethods(
+      operations,
+      contributionMaterializer.assertInitialized
+    ),
+    async executeDdl(ddl) {
+      await db.execute(sql.raw(ddl));
+    },
+    async ensureIndexMaterializationsTable() {
+      await db.execute(
+        sql.raw(generatePgCreateTableSQL(tables2.indexMaterializations))
+      );
+    },
+    async getIndexMaterialization(indexName) {
+      const t = tables2.indexMaterializations;
+      const rows = await db.select().from(t).where(eq(t.indexName, indexName));
+      const row = rows[0];
+      if (row === void 0) return void 0;
+      return mapMaterializationRow(row, 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(inArray(t.indexName, [...statusKeys]));
+      return rows.map(
+        (row) => mapMaterializationRow(row, POSTGRES_INDEX_MAT_TIMESTAMPS.decode)
+      );
+    },
+    async recordIndexMaterialization(params) {
+      const t = tables2.indexMaterializations;
+      await db.insert(t).values(
+        buildMaterializationInsertValues(
+          params,
+          POSTGRES_INDEX_MAT_TIMESTAMPS.encode
+        )
+      ).onConflictDoUpdate({
+        target: t.indexName,
+        set: 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(sql.raw(generatePgCreateTableSQL(tables2.kindRemovals)));
+    },
+    async getPendingKindRemovals(graphId) {
+      const t = tables2.kindRemovals;
+      const rows = await db.select().from(t).where(and(eq(t.graphId, graphId), isNull(t.removedAt)));
+      return rows.map(
+        (row) => mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
+      );
+    },
+    async getAllKindRemovals(graphId) {
+      const t = tables2.kindRemovals;
+      const rows = await db.select().from(t).where(eq(t.graphId, graphId));
+      return rows.map(
+        (row) => mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
+      );
+    },
+    async recordKindRemoval(params) {
+      const t = tables2.kindRemovals;
+      await db.insert(t).values(
+        buildKindRemovalInsertValues(
+          params,
+          POSTGRES_KIND_REMOVAL_TIMESTAMPS.encode
+        )
+      ).onConflictDoUpdate({
+        target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
+        set: buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
+      });
+    },
+    async ensureReconciliationMarkersTable() {
+      await db.execute(
+        sql.raw(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(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(analyzeStatement);
+    },
+    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 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
+          }
+        );
+      }
+      assertAdoptedDialect(externalTx, 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 = sql.raw(`SET LOCAL hnsw.ef_search = ${efSearch}`);
+    if (db instanceof PgTransaction) {
+      const [setting] = await execAll(
+        sql`SELECT current_setting('hnsw.ef_search') AS ef_search`
+      );
+      await execRun(setEfSearch);
+      const rows = await execAll(query);
+      if (setting !== void 0) {
+        await execRun(
+          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(sql.raw(statement));
+    });
+  }
+  const commonBackend = 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,
+    operationStrategy,
+    rowMappers: {
+      toEdgeRow,
+      toNodeRow,
+      toSchemaVersionRow,
+      toUniqueRow
+    }
+  });
+  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 = vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildUpsert(slot, params, nowIso());
+      try {
+        for (const statement of statements) {
+          await execRun(statement);
+        }
+      } catch (error) {
+        throw mapVectorWriteError(error, params);
+      }
+    },
+    async deleteEmbedding(params) {
+      const slot = vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildDelete(slot, params);
+      for (const statement of statements) {
+        await execRun(statement);
+      }
+    },
+    async vectorSearch(params) {
+      assertVectorSearchLimit(params.limit);
+      assertPgvectorEfSearch(params.efSearch);
+      const slot = vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const query = vectorStrategy.buildSearch(slot, params);
+      let rows;
+      try {
+        rows = await runVectorSearch(params.efSearch, query);
+      } catch (error) {
+        throw 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 = 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 = 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 = 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: coerceNumericScore(row.score),
+        rank: index + 1,
+        ...row.snippet === null ? {} : { snippet: row.snippet }
+      }));
+    },
+    async dropVectorIndex(params) {
+      if (vectorStrategy === void 0) return;
+      const slot = vectorSlotFromDropIndexParams(params);
+      const dropStatement = vectorStrategy.buildDropIndex?.(slot);
+      if (dropStatement === void 0) return;
+      try {
+        await execRun(dropStatement);
+      } catch (error) {
+        if (!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 : createVectorSlotLatch()
+  });
+}
+
+export { createPostgresBackend };
+//# sourceMappingURL=chunk-K5VREXMZ.js.map
+//# sourceMappingURL=chunk-K5VREXMZ.js.map