fhir-persistence 0.1.0 → 0.3.0

package/dist/esm/index.mjs

@@ -5049,7 +5049,35 @@ function quoteColumn(name) {
 function escapeLikeString(value) {
   return value.replace(/[%_\\]/g, "\\$&");
 }
-function buildWhereFragmentV2(impl, param) {
+function arrayContainsV2(col, values, dialect) {
+  if (dialect?.name === "postgres") {
+    const placeholders2 = values.map(() => "?").join(", ");
+    return { sql: `${col} && ARRAY[${placeholders2}]::text[]`, values: [...values] };
+  }
+  if (values.length === 1) {
+    return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value = ?)`, values: [values[0]] };
+  }
+  const placeholders = values.map(() => "?").join(", ");
+  return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value IN (${placeholders}))`, values: [...values] };
+}
+function arrayNotContainsV2(col, values, dialect) {
+  if (dialect?.name === "postgres") {
+    const placeholders2 = values.map(() => "?").join(", ");
+    return { sql: `NOT (${col} && ARRAY[${placeholders2}]::text[])`, values: [...values] };
+  }
+  if (values.length === 1) {
+    return { sql: `NOT EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value = ?)`, values: [values[0]] };
+  }
+  const placeholders = values.map(() => "?").join(", ");
+  return { sql: `NOT EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value IN (${placeholders}))`, values: [...values] };
+}
+function arrayContainsLikeV2(col, value, dialect) {
+  if (dialect?.name === "postgres") {
+    return { sql: `EXISTS (SELECT unnest FROM unnest(${col}) WHERE unnest LIKE ?)`, values: [value] };
+  }
+  return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value LIKE ?)`, values: [value] };
+}
+function buildWhereFragmentV2(impl, param, dialect) {
   if (param.modifier === "missing") {
     return buildMissingFragmentV2(impl, param);
   }
@@ -5057,7 +5085,7 @@ function buildWhereFragmentV2(impl, param) {
     return buildLookupTableFragmentV2(impl, param);
   }
   if (impl.strategy === "token-column") {
-    return buildTokenColumnFragmentV2(impl, param);
+    return buildTokenColumnFragmentV2(impl, param, dialect);
   }
   switch (impl.type) {
     case "string":
@@ -5068,11 +5096,11 @@ function buildWhereFragmentV2(impl, param) {
     case "quantity":
       return buildNumberFragmentV2(impl, param);
     case "reference":
-      return buildReferenceFragmentV2(impl, param);
+      return buildReferenceFragmentV2(impl, param, dialect);
     case "uri":
-      return buildUriFragmentV2(impl, param);
+      return buildUriFragmentV2(impl, param, dialect);
     case "token":
-      return buildTokenColumnFragmentV2(impl, param);
+      return buildTokenColumnFragmentV2(impl, param, dialect);
     default:
       return buildDefaultFragmentV2(impl, param);
   }
@@ -5163,29 +5191,21 @@ function buildNumberFragmentV2(impl, param) {
   });
   return buildOrFragmentV2Raw(col, op, numVals);
 }
-function buildReferenceFragmentV2(impl, param) {
+function buildReferenceFragmentV2(impl, param, dialect) {
   const col = quoteColumn(impl.columnName);
   if (impl.array) {
-    if (param.values.length === 1) {
-      return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value = ?)`, values: [param.values[0]] };
-    }
-    const placeholders = param.values.map(() => "?").join(", ");
-    return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value IN (${placeholders}))`, values: [...param.values] };
+    return arrayContainsV2(col, param.values, dialect);
   }
   return buildOrFragmentV2(col, "=", param.values);
 }
-function buildUriFragmentV2(impl, param) {
+function buildUriFragmentV2(impl, param, dialect) {
   const col = quoteColumn(impl.columnName);
   if (impl.array) {
-    if (param.values.length === 1) {
-      return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value = ?)`, values: [param.values[0]] };
-    }
-    const placeholders = param.values.map(() => "?").join(", ");
-    return { sql: `EXISTS (SELECT 1 FROM json_each(${col}) WHERE json_each.value IN (${placeholders}))`, values: [...param.values] };
+    return arrayContainsV2(col, param.values, dialect);
   }
   return buildOrFragmentV2(col, "=", param.values);
 }
-function buildTokenColumnFragmentV2(impl, param) {
+function buildTokenColumnFragmentV2(impl, param, dialect) {
   const textCol = quoteColumn(`__${impl.columnName}Text`);
   const sortCol = quoteColumn(`__${impl.columnName}Sort`);
   if (param.modifier === "text") {
@@ -5197,11 +5217,14 @@ function buildTokenColumnFragmentV2(impl, param) {
     const vals = [];
     for (const value of param.values) {
       if (value.endsWith("|")) {
-        conds.push(`EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value LIKE ?)`);
-        vals.push(value + "%");
+        const frag = arrayContainsLikeV2(textCol, value + "%", dialect);
+        conds.push(frag.sql);
+        vals.push(...frag.values);
       } else {
-        conds.push(`EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value = ?)`);
-        vals.push(value.startsWith("|") ? value.slice(1) : value);
+        const resolved = value.startsWith("|") ? value.slice(1) : value;
+        const frag = arrayContainsV2(textCol, [resolved], dialect);
+        conds.push(frag.sql);
+        vals.push(...frag.values);
       }
     }
     const inner = conds.length === 1 ? conds[0] : `(${conds.join(" OR ")})`;
@@ -5210,17 +5233,9 @@ function buildTokenColumnFragmentV2(impl, param) {
   }
   const resolvedValues = param.values.map((v) => v.startsWith("|") ? v.slice(1) : v);
   if (param.modifier === "not") {
-    if (resolvedValues.length === 1) {
-      return { sql: `NOT EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value = ?)`, values: [resolvedValues[0]] };
-    }
-    const placeholders2 = resolvedValues.map(() => "?").join(", ");
-    return { sql: `NOT EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value IN (${placeholders2}))`, values: [...resolvedValues] };
+    return arrayNotContainsV2(textCol, resolvedValues, dialect);
   }
-  if (resolvedValues.length === 1) {
-    return { sql: `EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value = ?)`, values: [resolvedValues[0]] };
-  }
-  const placeholders = resolvedValues.map(() => "?").join(", ");
-  return { sql: `EXISTS (SELECT 1 FROM json_each(${textCol}) WHERE json_each.value IN (${placeholders}))`, values: [...resolvedValues] };
+  return arrayContainsV2(textCol, resolvedValues, dialect);
 }
 function buildDefaultFragmentV2(impl, param) {
   const col = quoteColumn(impl.columnName);
@@ -5250,7 +5265,7 @@ function buildLikeFragmentV2(col, values, prefix, suffix) {
   }
   return { sql: `(${conds.join(" OR ")})`, values: vals };
 }
-function buildChainedFragmentV2(param, chain, registry, sourceResourceType) {
+function buildChainedFragmentV2(param, chain, registry, sourceResourceType, dialect) {
   const targetImpl = resolveImplV2(
     { code: chain.targetParam, values: param.values, modifier: param.modifier, prefix: param.prefix },
     registry,
@@ -5263,7 +5278,7 @@ function buildChainedFragmentV2(param, chain, registry, sourceResourceType) {
     modifier: param.modifier,
     prefix: param.prefix
   };
-  const innerFragment = buildWhereFragmentV2(targetImpl, innerParam);
+  const innerFragment = buildWhereFragmentV2(targetImpl, innerParam, dialect);
   if (!innerFragment) return null;
   const innerSql = rewriteColumnRefsForAlias(innerFragment.sql, "__target");
   const refTable = `${sourceResourceType}_References`;
@@ -5280,11 +5295,11 @@ function buildChainedFragmentV2(param, chain, registry, sourceResourceType) {
   ].join("\n");
   return { sql, values: [param.code, chain.targetType, ...innerFragment.values] };
 }
-function buildWhereClauseV2(params, registry, resourceType) {
+function buildWhereClauseV2(params, registry, resourceType, dialect) {
   const fragments = [];
   for (const param of params) {
     if (param.chain) {
-      const fragment2 = buildChainedFragmentV2(param, param.chain, registry, resourceType);
+      const fragment2 = buildChainedFragmentV2(param, param.chain, registry, resourceType, dialect);
       if (fragment2) {
         fragments.push(fragment2);
       }
@@ -5292,7 +5307,7 @@ function buildWhereClauseV2(params, registry, resourceType) {
     }
     const impl = resolveImplV2(param, registry, resourceType);
     if (!impl) continue;
-    const fragment = buildWhereFragmentV2(impl, param);
+    const fragment = buildWhereFragmentV2(impl, param, dialect);
     if (fragment) {
       fragments.push(fragment);
     }
@@ -5346,7 +5361,7 @@ function quoteTable(name) {
   return `"${name}"`;
 }
 var SEARCH_COLUMNS_V2 = ['"id"', '"versionId"', '"content"', '"lastUpdated"', '"deleted"'].join(", ");
-function buildSearchSQLv2(request, registry) {
+function buildSearchSQLv2(request, registry, dialect) {
   const tableName = quoteTable(request.resourceType);
   const parts = [];
   const allValues = [];
@@ -5355,11 +5370,15 @@ function buildSearchSQLv2(request, registry) {
   const whereConditions = [];
   whereConditions.push('"deleted" = 0');
   if (request.compartment) {
-    whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    if (dialect?.name === "postgres") {
+      whereConditions.push('"compartments" && ARRAY[?]::text[]');
+    } else {
+      whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    }
     allValues.push(request.compartment.id);
   }
   if (request.params.length > 0) {
-    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType);
+    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType, dialect);
     if (whereFragment) {
       whereConditions.push(whereFragment.sql);
       allValues.push(...whereFragment.values);
@@ -5377,7 +5396,7 @@ function buildSearchSQLv2(request, registry) {
   }
   return { sql: parts.join("\n"), values: allValues };
 }
-function buildCountSQLv2(request, registry) {
+function buildCountSQLv2(request, registry, dialect) {
   const tableName = quoteTable(request.resourceType);
   const parts = [];
   const allValues = [];
@@ -5386,11 +5405,15 @@ function buildCountSQLv2(request, registry) {
   const whereConditions = [];
   whereConditions.push('"deleted" = 0');
   if (request.compartment) {
-    whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    if (dialect?.name === "postgres") {
+      whereConditions.push('"compartments" && ARRAY[?]::text[]');
+    } else {
+      whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    }
     allValues.push(request.compartment.id);
   }
   if (request.params.length > 0) {
-    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType);
+    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType, dialect);
     if (whereFragment) {
       whereConditions.push(whereFragment.sql);
       allValues.push(...whereFragment.values);
@@ -5412,7 +5435,7 @@ function buildOrderByV2(sort, registry, resourceType) {
   }
   return clauses.length > 0 ? clauses.join(", ") : '"lastUpdated" DESC';
 }
-function buildTwoPhaseSearchSQLv2(request, registry) {
+function buildTwoPhaseSearchSQLv2(request, registry, dialect) {
   const tableName = quoteTable(request.resourceType);
   const p1Parts = [];
   const p1Values = [];
@@ -5421,11 +5444,15 @@ function buildTwoPhaseSearchSQLv2(request, registry) {
   const whereConditions = [];
   whereConditions.push('"deleted" = 0');
   if (request.compartment) {
-    whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    if (dialect?.name === "postgres") {
+      whereConditions.push('"compartments" && ARRAY[?]::text[]');
+    } else {
+      whereConditions.push('EXISTS (SELECT 1 FROM json_each("compartments") WHERE json_each.value = ?)');
+    }
     p1Values.push(request.compartment.id);
   }
   if (request.params.length > 0) {
-    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType);
+    const whereFragment = buildWhereClauseV2(request.params, registry, request.resourceType, dialect);
     if (whereFragment) {
       whereConditions.push(whereFragment.sql);
       p1Values.push(...whereFragment.values);
@@ -5556,12 +5583,13 @@ function buildPaginationContext(baseUrl, resourceType, queryParams, count, offse
 
 // src/search/search-executor.ts
 async function executeSearchV2(adapter, request, registry, options) {
-  const searchSQL = buildSearchSQLv2(request, registry);
+  const dialect = options?.dialect;
+  const searchSQL = buildSearchSQLv2(request, registry, dialect);
   const rows = await adapter.query(searchSQL.sql, searchSQL.values);
   const resources = mapRowsToResourcesV2(rows);
   let total;
   if (options?.total === "accurate") {
-    const countSQL = buildCountSQLv2(request, registry);
+    const countSQL = buildCountSQLv2(request, registry, dialect);
     const countRow = await adapter.queryOne(countSQL.sql, countSQL.values);
     total = countRow?.count ?? 0;
   }
@@ -5868,166 +5896,6 @@ function planSearch(request, registry, options) {
   };
 }
 
-// src/db/sqlite-adapter.ts
-import initSqlJs from "sql.js";
-var sqlJsInitPromise = null;
-async function getSqlJs() {
-  if (!sqlJsInitPromise) {
-    sqlJsInitPromise = initSqlJs();
-  }
-  return sqlJsInitPromise;
-}
-var SQLiteAdapter = class {
-  /**
-   * @param path - Database file path, or ':memory:' for in-memory database.
-   * @param data - Optional Uint8Array of an existing database file to load.
-   */
-  constructor(_path = ":memory:", data) {
-    this.data = data;
-    this.initPromise = this.initialize();
-  }
-  db = null;
-  initPromise;
-  async initialize() {
-    const SQL = await getSqlJs();
-    this.db = new SQL.Database(this.data);
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run("PRAGMA foreign_keys = ON");
-  }
-  async getDb() {
-    await this.initPromise;
-    if (!this.db) {
-      throw new Error("SQLiteAdapter: database is closed");
-    }
-    return this.db;
-  }
-  async execute(sql, params = []) {
-    const db = await this.getDb();
-    db.run(sql, params);
-    const result = db.exec("SELECT changes() as c");
-    const changes = result.length > 0 ? result[0].values[0][0] : 0;
-    return { changes };
-  }
-  async query(sql, params = []) {
-    const db = await this.getDb();
-    const stmt = db.prepare(sql);
-    stmt.bind(params);
-    const rows = [];
-    while (stmt.step()) {
-      rows.push(stmt.getAsObject());
-    }
-    stmt.free();
-    return rows;
-  }
-  async queryOne(sql, params = []) {
-    const db = await this.getDb();
-    const stmt = db.prepare(sql);
-    stmt.bind(params);
-    let result;
-    if (stmt.step()) {
-      result = stmt.getAsObject();
-    }
-    stmt.free();
-    return result;
-  }
-  async *queryStream(sql, params = []) {
-    const db = await this.getDb();
-    const stmt = db.prepare(sql);
-    stmt.bind(params);
-    try {
-      while (stmt.step()) {
-        yield stmt.getAsObject();
-      }
-    } finally {
-      stmt.free();
-    }
-  }
-  prepare(sql) {
-    if (!this.db) {
-      throw new Error("SQLiteAdapter: database not initialized. Await an operation first.");
-    }
-    const db = this.db;
-    const stmt = db.prepare(sql);
-    return {
-      query(params = []) {
-        stmt.bind(params);
-        const rows = [];
-        while (stmt.step()) {
-          rows.push(stmt.getAsObject());
-        }
-        stmt.reset();
-        return rows;
-      },
-      execute(params = []) {
-        stmt.bind(params);
-        stmt.step();
-        stmt.reset();
-        const changesResult = db.exec("SELECT changes() as c, last_insert_rowid() as r");
-        const changes = changesResult.length > 0 ? changesResult[0].values[0][0] : 0;
-        const lastInsertRowid = changesResult.length > 0 ? changesResult[0].values[0][1] : void 0;
-        return { changes, lastInsertRowid };
-      },
-      finalize() {
-        stmt.free();
-      }
-    };
-  }
-  async transaction(fn) {
-    const db = await this.getDb();
-    db.run("BEGIN IMMEDIATE");
-    const ctx = {
-      execute(sql, params = []) {
-        db.run(sql, params);
-        const result = db.exec("SELECT changes() as c");
-        const changes = result.length > 0 ? result[0].values[0][0] : 0;
-        return { changes };
-      },
-      query(sql, params = []) {
-        const stmt = db.prepare(sql);
-        stmt.bind(params);
-        const rows = [];
-        while (stmt.step()) {
-          rows.push(stmt.getAsObject());
-        }
-        stmt.free();
-        return rows;
-      },
-      queryOne(sql, params = []) {
-        const stmt = db.prepare(sql);
-        stmt.bind(params);
-        let result;
-        if (stmt.step()) {
-          result = stmt.getAsObject();
-        }
-        stmt.free();
-        return result;
-      }
-    };
-    try {
-      const result = await fn(ctx);
-      db.run("COMMIT");
-      return result;
-    } catch (err) {
-      db.run("ROLLBACK");
-      throw err;
-    }
-  }
-  async close() {
-    await this.initPromise;
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  /**
-   * Export the database as a Uint8Array (for file persistence).
-   */
-  async export() {
-    const db = await this.getDb();
-    return db.export();
-  }
-};
-
 // src/db/better-sqlite3-adapter.ts
 import Database from "better-sqlite3";
 var BetterSqlite3Adapter = class {
@@ -6105,14 +5973,14 @@ var BetterSqlite3Adapter = class {
   async transaction(fn) {
     const db = this.ensureOpen();
     const ctx = {
-      execute(sql, params = []) {
+      async execute(sql, params = []) {
         const result = db.prepare(sql).run(...params);
         return { changes: result.changes };
       },
-      query(sql, params = []) {
+      async query(sql, params = []) {
         return db.prepare(sql).all(...params);
       },
-      queryOne(sql, params = []) {
+      async queryOne(sql, params = []) {
         return db.prepare(sql).get(...params);
       }
     };
@@ -6157,6 +6025,202 @@ var BetterSqlite3Adapter = class {
   }
 };
 
+// src/db/postgres-adapter.ts
+function rewritePlaceholders(sql) {
+  let result = "";
+  let paramIndex = 1;
+  let inString = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'" && !inString) {
+      inString = true;
+      result += ch;
+    } else if (ch === "'" && inString) {
+      if (i + 1 < sql.length && sql[i + 1] === "'") {
+        result += "''";
+        i++;
+      } else {
+        inString = false;
+        result += ch;
+      }
+    } else if (ch === "?" && !inString) {
+      result += `$${paramIndex}`;
+      paramIndex++;
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+var PostgresAdapter = class {
+  pool;
+  closed = false;
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async execute(sql, params = []) {
+    this.ensureNotClosed();
+    const pgSql = rewritePlaceholders(sql);
+    const result = await this.pool.query(pgSql, params);
+    return { changes: result.rowCount ?? 0 };
+  }
+  async query(sql, params = []) {
+    this.ensureNotClosed();
+    const pgSql = rewritePlaceholders(sql);
+    const result = await this.pool.query(pgSql, params);
+    return result.rows;
+  }
+  async queryOne(sql, params = []) {
+    this.ensureNotClosed();
+    const pgSql = rewritePlaceholders(sql);
+    const result = await this.pool.query(pgSql, params);
+    return result.rows[0] ?? void 0;
+  }
+  async *queryStream(sql, params = []) {
+    this.ensureNotClosed();
+    const pgSql = rewritePlaceholders(sql);
+    const result = await this.pool.query(pgSql, params);
+    for (const row of result.rows) {
+      yield row;
+    }
+  }
+  prepare(_sql) {
+    throw new Error("PostgresAdapter.prepare() is not supported. Use query() or execute() instead.");
+  }
+  async transaction(fn) {
+    this.ensureNotClosed();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const ctx = {
+        execute: async (sql, params = []) => {
+          const pgSql = rewritePlaceholders(sql);
+          const result2 = await client.query(pgSql, params);
+          return { changes: result2.rowCount ?? 0 };
+        },
+        query: async (sql, params = []) => {
+          const pgSql = rewritePlaceholders(sql);
+          const result2 = await client.query(pgSql, params);
+          return result2.rows;
+        },
+        queryOne: async (sql, params = []) => {
+          const pgSql = rewritePlaceholders(sql);
+          const result2 = await client.query(pgSql, params);
+          return result2.rows[0] ?? void 0;
+        }
+      };
+      const result = await fn(ctx);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async close() {
+    if (!this.closed) {
+      this.closed = true;
+      await this.pool.end();
+    }
+  }
+  ensureNotClosed() {
+    if (this.closed) {
+      throw new Error("PostgresAdapter: pool is closed");
+    }
+  }
+};
+
+// src/db/sqlite-dialect.ts
+var SQLiteDialect = class {
+  name = "sqlite";
+  placeholder(_index) {
+    return "?";
+  }
+  textArrayContains(column, paramCount, _paramStartIndex) {
+    const placeholders = Array.from({ length: paramCount }, () => "?").join(", ");
+    return {
+      sql: `EXISTS (SELECT 1 FROM json_each("${column}") WHERE value IN (${placeholders}))`,
+      values: []
+      // caller supplies values separately
+    };
+  }
+  like(column, _paramIndex) {
+    return `"${column}" LIKE ? ESCAPE '\\'`;
+  }
+  limitOffset(_paramStartIndex) {
+    return { sql: "LIMIT ? OFFSET ?" };
+  }
+  arrayLiteral(values) {
+    return JSON.stringify(values);
+  }
+  timestampType() {
+    return "TEXT";
+  }
+  booleanType() {
+    return "INTEGER";
+  }
+  textArrayType() {
+    return "TEXT";
+  }
+  upsertSuffix(conflictColumn, updateColumns) {
+    const sets = updateColumns.map((c) => `"${c}" = excluded."${c}"`).join(", ");
+    return `ON CONFLICT("${conflictColumn}") DO UPDATE SET ${sets}`;
+  }
+  autoIncrementPK() {
+    return "INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT";
+  }
+};
+
+// src/db/postgres-dialect.ts
+var PostgresDialect = class {
+  name = "postgres";
+  placeholder(index) {
+    return `$${index}`;
+  }
+  textArrayContains(column, paramCount, paramStartIndex) {
+    const placeholders = Array.from(
+      { length: paramCount },
+      (_, i) => `$${paramStartIndex + i}`
+    ).join(", ");
+    return {
+      sql: `"${column}" && ARRAY[${placeholders}]::text[]`,
+      values: []
+      // caller supplies values separately
+    };
+  }
+  like(column, paramIndex) {
+    return `"${column}" LIKE $${paramIndex}`;
+  }
+  limitOffset(paramStartIndex) {
+    return { sql: `LIMIT $${paramStartIndex} OFFSET $${paramStartIndex + 1}` };
+  }
+  arrayLiteral(values) {
+    if (values.length === 0) {
+      return "ARRAY[]::text[]";
+    }
+    const escaped = values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+    return `ARRAY[${escaped}]::text[]`;
+  }
+  timestampType() {
+    return "TIMESTAMPTZ";
+  }
+  booleanType() {
+    return "BOOLEAN";
+  }
+  textArrayType() {
+    return "TEXT[]";
+  }
+  upsertSuffix(conflictColumn, updateColumns) {
+    const sets = updateColumns.map((c) => `"${c}" = excluded."${c}"`).join(", ");
+    return `ON CONFLICT("${conflictColumn}") DO UPDATE SET ${sets}`;
+  }
+  autoIncrementPK() {
+    return "INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY";
+  }
+};
+
 // src/store/fhir-store.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 var FhirStore = class {
@@ -6197,11 +6261,11 @@ var FhirStore = class {
       lastUpdated: now,
       deleted: 0
     };
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const mainSQL = buildInsertMainSQLv2(resourceType, mainRow);
-      tx.execute(mainSQL.sql, mainSQL.values);
+      await tx.execute(mainSQL.sql, mainSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
     });
     return persisted;
   }
@@ -6275,13 +6339,13 @@ var FhirStore = class {
       lastUpdated: now,
       deleted: 0
     };
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const updateSQL = buildUpdateMainSQLv2(resourceType, mainRow);
-      tx.execute(updateSQL.sql, updateSQL.values);
+      await tx.execute(updateSQL.sql, updateSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
       const delRefSQL = buildDeleteReferencesSQLv2(`${resourceType}_References`);
-      tx.execute(delRefSQL, [id]);
+      await tx.execute(delRefSQL, [id]);
     });
     return persisted;
   }
@@ -6313,13 +6377,13 @@ var FhirStore = class {
       lastUpdated: now,
       deleted: 1
     };
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const updateSQL = buildUpdateMainSQLv2(resourceType, deleteRow);
-      tx.execute(updateSQL.sql, updateSQL.values);
+      await tx.execute(updateSQL.sql, updateSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
       const delRefSQL = buildDeleteReferencesSQLv2(`${resourceType}_References`);
-      tx.execute(delRefSQL, [id]);
+      await tx.execute(delRefSQL, [id]);
     });
   }
   // ---------------------------------------------------------------------------
@@ -6762,11 +6826,11 @@ var FhirPersistence = class {
       lastUpdated: now,
       deleted: 0
     };
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const mainSQL = buildInsertMainSQLv2(resourceType, mainRow);
-      tx.execute(mainSQL.sql, mainSQL.values);
+      await tx.execute(mainSQL.sql, mainSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
     });
     return persisted;
   }
@@ -6843,11 +6907,11 @@ var FhirPersistence = class {
       lastUpdated: now,
       deleted: 0
     };
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const updateSQL = buildUpdateMainSQLv2(resourceType, mainRow);
-      tx.execute(updateSQL.sql, updateSQL.values);
+      await tx.execute(updateSQL.sql, updateSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
     });
     return persisted;
   }
@@ -6880,11 +6944,11 @@ var FhirPersistence = class {
       deleted: 1
     };
     await this.pipeline.deleteIndex(resourceType, id);
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       const updateSQL = buildUpdateMainSQLv2(resourceType, deleteRow);
-      tx.execute(updateSQL.sql, updateSQL.values);
+      await tx.execute(updateSQL.sql, updateSQL.values);
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
-      tx.execute(histSQL.sql, histSQL.values);
+      await tx.execute(histSQL.sql, histSQL.values);
     });
   }
   // ---------------------------------------------------------------------------
@@ -7550,22 +7614,22 @@ var MigrationRunnerV2 = class {
     return new Set(rows.map((r) => r.version));
   }
   async applyMigration(migration) {
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       for (const sql of migration.up) {
-        tx.execute(sql);
+        await tx.execute(sql);
       }
-      tx.execute(
+      await tx.execute(
         `INSERT INTO "${TRACKING_TABLE_V2}" ("version", "description", "type") VALUES (?, ?, ?)`,
         [migration.version, migration.description, migration.type]
       );
     });
   }
   async revertMigration(migration) {
-    await this.adapter.transaction((tx) => {
+    await this.adapter.transaction(async (tx) => {
       for (const sql of migration.down) {
-        tx.execute(sql);
+        await tx.execute(sql);
       }
-      tx.execute(
+      await tx.execute(
         `DELETE FROM "${TRACKING_TABLE_V2}" WHERE "version" = ?`,
         [migration.version]
       );
@@ -7821,10 +7885,10 @@ var TerminologyCodeRepo = class {
     const chunkSize = 100;
     for (let i = 0; i < codes.length; i += chunkSize) {
       const chunk = codes.slice(i, i + chunkSize);
-      const result = await this.adapter.transaction((tx) => {
+      const result = await this.adapter.transaction(async (tx) => {
         let count = 0;
         for (const c of chunk) {
-          const r = tx.execute(
+          const r = await tx.execute(
             `INSERT OR IGNORE INTO "${CODES_TABLE}" ("system", "code", "display") VALUES (?, ?, ?)`,
             [c.system, c.code, c.display]
           );
@@ -8674,6 +8738,8 @@ export {
   PROJECT_ADMIN_RESOURCE_TYPES,
   PROTECTED_RESOURCE_TYPES,
   PackageRegistryRepo,
+  PostgresAdapter,
+  PostgresDialect,
   ReindexScheduler,
   RepositoryError,
   ResourceCacheV2,
@@ -8682,7 +8748,7 @@ export {
   ResourceVersionConflictError,
   SCHEMA_VERSION,
   SEARCH_PREFIXES,
-  SQLiteAdapter,
+  SQLiteDialect,
   SearchLogger,
   SearchParameterRegistry,
   StructureDefinitionRegistry,