@nicia-ai/typegraph 0.28.1 → 0.30.0

package/dist/backend/postgres/index.js

@@ -1,755 +1,13 @@
-import { quoteIdentifier } from '../../chunk-3EUKJEQ3.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, tables, 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, generateVectorIndexName, dropPostgresVectorIndex, coerceNumericScore, createPostgresVectorIndex, gateFulltext, compileQueryWithDialect, formatPostgresTimestamp, getOrCreateLru } from '../../chunk-TKM2WDT4.js';
-export { createPostgresTables, edges, embeddings, fulltext, generatePostgresDDL, generatePostgresMigrationSQL, nodes, schemaVersions, tables, uniques } from '../../chunk-TKM2WDT4.js';
-import { POSTGRES_CAPABILITIES } from '../../chunk-PCHTTG42.js';
-import '../../chunk-O57GYGYK.js';
-import { tsvectorStrategy, buildFulltextCapabilities } from '../../chunk-ZTREJOGB.js';
-import '../../chunk-EJCDOA37.js';
-import '../../chunk-OOS2RKRH.js';
-import '../../chunk-WVQXAFP3.js';
-import { ConfigurationError } from '../../chunk-U5ROKVRF.js';
-import '../../chunk-NZ5PMBTG.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 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 (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 toEmbeddingRow(row) {
-  let embedding;
-  if (typeof row.embedding === "string") {
-    const content = row.embedding.slice(1, -1);
-    embedding = content === "" ? [] : content.split(",").map((s) => Number.parseFloat(s.trim()));
-  } else if (Array.isArray(row.embedding)) {
-    embedding = row.embedding;
-  } else {
-    embedding = [];
-  }
-  return {
-    graph_id: row.graph_id,
-    node_kind: row.node_kind,
-    node_id: row.node_id,
-    field_path: row.field_path,
-    embedding,
-    dimensions: row.dimensions,
-    created_at: formatPostgresTimestamp(row.created_at) ?? "",
-    updated_at: formatPostgresTimestamp(row.updated_at) ?? ""
-  };
-}
-function buildPostgresCapabilities(strategy) {
-  return {
-    ...POSTGRES_CAPABILITIES,
-    vector: {
-      supported: true,
-      metrics: ["cosine", "l2", "inner_product"],
-      indexTypes: ["hnsw", "ivfflat", "none"],
-      maxDimensions: 16e3
-      // pgvector limit
-    },
-    fulltext: buildFulltextCapabilities(strategy)
-  };
-}
-function createPostgresBackend(db, options = {}) {
-  const tables2 = options.tables ?? tables;
-  const fulltextStrategy = options.fulltext ?? tsvectorStrategy;
-  const baseCapabilities = buildPostgresCapabilities(fulltextStrategy);
-  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),
-    embeddings: getTableName(tables2.embeddings),
-    fulltext: tables2.fulltextTableName,
-    uniques: getTableName(tables2.uniques)
-  };
-  const analyzeStatement = sql`ANALYZE ${sql.join(
-    [
-      tableNames.nodes,
-      tableNames.edges,
-      getTableName(tables2.uniques),
-      tableNames.embeddings,
-      tableNames.fulltext
-    ].map((name) => quoteIdentifier(name)),
-    sql`, `
-  )}`;
-  const operationStrategy = createPostgresOperationStrategy(
-    tables2,
-    fulltextStrategy
-  );
-  const operations = createPostgresOperationBackend({
-    db,
-    executionAdapter,
-    adapterOptions,
-    operationStrategy,
-    tableNames,
-    capabilities,
-    fulltextStrategy
-  });
-  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
-      });
-      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
-    });
-    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
-  } = 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);
-    });
-  }
-  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 operationBackend = {
-    ...commonBackend,
-    ...executeRawMethod,
-    capabilities,
-    fulltextStrategy,
-    dialect: "postgres",
-    tableNames,
-    // === Embedding Operations ===
-    async upsertEmbedding(params) {
-      const timestamp = nowIso();
-      const query = operationStrategy.buildUpsertEmbedding(params, timestamp);
-      await execRun(query);
-    },
-    async deleteEmbedding(params) {
-      const query = operationStrategy.buildDeleteEmbedding(params);
-      await execRun(query);
-    },
-    async getEmbedding(graphId, nodeKind, nodeId, fieldPath) {
-      const query = operationStrategy.buildGetEmbedding(
-        graphId,
-        nodeKind,
-        nodeId,
-        fieldPath
-      );
-      const row = await execGet(query);
-      return row ? toEmbeddingRow(row) : void 0;
-    },
-    async vectorSearch(params) {
-      const query = operationStrategy.buildVectorSearch(params);
-      const rows = await runVectorSearch(params.efSearch, query);
-      return rows.map((row) => ({
-        nodeId: row.node_id,
-        score: row.score
-      }));
-    },
-    async createVectorIndex(params) {
-      const indexOptions = {
-        graphId: params.graphId,
-        nodeKind: params.nodeKind,
-        fieldPath: params.fieldPath,
-        dimensions: params.dimensions,
-        embeddingsTableName: tableNames.embeddings,
-        indexType: params.indexType,
-        metric: params.metric,
-        ...params.indexParams?.m === void 0 ? {} : { hnswM: params.indexParams.m },
-        ...params.indexParams?.efConstruction === void 0 ? {} : { hnswEfConstruction: params.indexParams.efConstruction },
-        ...params.indexParams?.lists === void 0 ? {} : { ivfflatLists: params.indexParams.lists },
-        ...params.concurrent === true ? { concurrent: true } : {}
-      };
-      const result = await createPostgresVectorIndex(db, indexOptions);
-      if (!result.success) {
-        throw new Error(
-          result.message ?? "Failed to create PostgreSQL vector index"
-        );
-      }
-    },
-    // === 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) {
-      const metrics = capabilities.vector?.metrics ?? ["cosine"];
-      await Promise.all(
-        metrics.map(async (metric) => {
-          const indexName = generateVectorIndexName(
-            params.graphId,
-            params.nodeKind,
-            params.fieldPath,
-            metric
-          );
-          const result = await dropPostgresVectorIndex(db, indexName);
-          if (!result.success) {
-            throw new Error(
-              result.message ?? "Failed to drop PostgreSQL vector index"
-            );
-          }
-        })
-      );
-    },
-    // === 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
-  });
-}
-
-export { createPostgresBackend };
+export { createPostgresBackend } from '../../chunk-K5VREXMZ.js';
+import '../../chunk-FVIGJTS7.js';
+export { createPostgresTables, edges, fulltext, generatePostgresDDL, generatePostgresMigrationSQL, nodes, schemaVersions, tables, uniques } from '../../chunk-N2OEOGBB.js';
+import '../../chunk-633N7DSE.js';
+import '../../chunk-M6OC455F.js';
+import '../../chunk-AI3RNREM.js';
+import '../../chunk-R4JOBEJU.js';
+import '../../chunk-MXE2U3EX.js';
+import '../../chunk-454I6GDF.js';
+import '../../chunk-TQOYM4LN.js';
+import '../../chunk-K5P5OZXS.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map