fhir-persistence 0.9.0 → 0.10.0

package/dist/esm/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/registry/structure-definition-registry.ts
 var StructureDefinitionRegistry = class {
   profiles = /* @__PURE__ */ new Map();
@@ -4145,6 +4152,18 @@ var ResourceGoneError = class extends RepositoryError {
     this.resourceId = id;
   }
 };
+var PreconditionFailedError = class extends RepositoryError {
+  name = "PreconditionFailedError";
+  resourceType;
+  matchCount;
+  constructor(resourceType, matchCount) {
+    super(
+      `Conditional operation on ${resourceType} matched ${matchCount} resources (expected 0 or 1)`
+    );
+    this.resourceType = resourceType;
+    this.matchCount = matchCount;
+  }
+};
 var ResourceVersionConflictError = class extends RepositoryError {
   name = "ResourceVersionConflictError";
   resourceType;
@@ -5122,6 +5141,15 @@ function buildLookupTableFragmentV2(impl, param, resourceType) {
   const colRef = `__lookup."${column}"`;
   const outerIdRef = `"${resourceType}"."id"`;
   if (param.modifier === "exact") {
+    if (table === "HumanName" && column === "name") {
+      const colConds = [];
+      const allVals = [];
+      for (const v of param.values) {
+        colConds.push(`__lookup."family" = ? OR __lookup."given" = ?`);
+        allVals.push(v, v);
+      }
+      return { sql: `EXISTS (SELECT 1 FROM "${table}" __lookup WHERE __lookup."resourceId" = ${outerIdRef} AND (${colConds.join(" OR ")}))`, values: allVals };
+    }
     if (param.values.length === 1) {
       return { sql: `EXISTS (SELECT 1 FROM "${table}" __lookup WHERE __lookup."resourceId" = ${outerIdRef} AND ${colRef} = ?)`, values: [param.values[0]] };
     }
@@ -6302,9 +6330,41 @@ var FhirStore = class {
     const selectSQL = buildSelectByIdSQLv2(resourceType);
     const current = await this.adapter.queryOne(selectSQL, [id]);
     if (!current) {
+      if (options?.upsert) {
+        const created = await this.createResource(resourceType, resource, { assignedId: id });
+        return { resource: created, created: true };
+      }
       throw new ResourceNotFoundError(resourceType, id);
     }
     if (current.deleted === 1) {
+      if (options?.upsert) {
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const versionId2 = randomUUID3();
+        const persisted2 = {
+          ...resource,
+          resourceType,
+          id,
+          meta: { ...resource.meta, versionId: versionId2, lastUpdated: now2 }
+        };
+        const content2 = JSON.stringify(persisted2);
+        const mainRow2 = {
+          id,
+          versionId: versionId2,
+          content: content2,
+          lastUpdated: now2,
+          deleted: 0,
+          _source: persisted2.meta?.source ?? null,
+          _profile: persisted2.meta?.profile ? JSON.stringify(persisted2.meta.profile) : null
+        };
+        const historyRow2 = { id, versionId: versionId2, content: content2, lastUpdated: now2, deleted: 0 };
+        await this.adapter.transaction(async (tx) => {
+          const updateSQL = buildUpdateMainSQLv2(resourceType, mainRow2);
+          await tx.execute(updateSQL.sql, updateSQL.values);
+          const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow2);
+          await tx.execute(histSQL.sql, histSQL.values);
+        });
+        return { resource: persisted2, created: true };
+      }
       throw new ResourceGoneError(resourceType, id);
     }
     if (options?.ifMatch) {
@@ -6355,7 +6415,7 @@ var FhirStore = class {
       const delRefSQL = buildDeleteReferencesSQLv2(`${resourceType}_References`);
       await tx.execute(delRefSQL, [id]);
     });
-    return persisted;
+    return { resource: persisted, created: false };
   }
   // ---------------------------------------------------------------------------
   // DELETE (soft)
@@ -6425,6 +6485,24 @@ var FhirStore = class {
     }));
   }
   // ---------------------------------------------------------------------------
+  // TYPE-LEVEL HISTORY (PERS-06)
+  // ---------------------------------------------------------------------------
+  async readTypeHistory(resourceType, options) {
+    const { sql, values } = buildTypeHistorySQLv2(
+      `${resourceType}_History`,
+      options
+    );
+    const rows = await this.adapter.query(sql, values);
+    return rows.map((row) => ({
+      id: row.id,
+      versionId: row.versionId,
+      lastUpdated: row.lastUpdated,
+      deleted: row.deleted === 1,
+      resourceType,
+      resource: row.deleted === 1 ? null : JSON.parse(row.content)
+    }));
+  }
+  // ---------------------------------------------------------------------------
   // WRITE REFERENCES (utility for external callers)
   // ---------------------------------------------------------------------------
   async writeReferences(resourceType, resourceId, refs) {
@@ -6806,6 +6884,25 @@ var FhirPersistence = class {
   // CREATE
   // ---------------------------------------------------------------------------
   async createResource(resourceType, resource, options) {
+    if (options?.ifNoneExist && options.ifNoneExist.length > 0) {
+      const searchSQL = buildSearchSQLv2(
+        { resourceType, params: options.ifNoneExist, count: 2 },
+        this.registry
+      );
+      const matches = await this.adapter.query(
+        searchSQL.sql,
+        searchSQL.values
+      );
+      if (matches.length > 1) {
+        throw new PreconditionFailedError(resourceType, matches.length);
+      }
+      if (matches.length === 1) {
+        return {
+          resource: JSON.parse(matches[0].content),
+          created: false
+        };
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = options?.assignedId ?? resource.id ?? randomUUID4();
     const versionId = randomUUID4();
@@ -6845,7 +6942,7 @@ var FhirPersistence = class {
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
       await tx.execute(histSQL.sql, histSQL.values);
     });
-    return persisted;
+    return { resource: persisted, created: true };
   }
   // ---------------------------------------------------------------------------
   // READ
@@ -6872,9 +6969,44 @@ var FhirPersistence = class {
     const selectSQL = buildSelectByIdSQLv2(resourceType);
     const current = await this.adapter.queryOne(selectSQL, [id]);
     if (!current) {
+      if (options?.upsert) {
+        const result = await this.createResource(resourceType, resource, { assignedId: id });
+        return { resource: result.resource, created: true };
+      }
       throw new ResourceNotFoundError(resourceType, id);
     }
     if (current.deleted === 1) {
+      if (options?.upsert) {
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const versionId2 = randomUUID4();
+        const persisted2 = {
+          ...resource,
+          resourceType,
+          id,
+          meta: { ...resource.meta, versionId: versionId2, lastUpdated: now2 }
+        };
+        const impls2 = this.getImpls(resourceType);
+        const indexResult2 = await this.pipeline.indexResource(resourceType, persisted2, impls2);
+        const content2 = JSON.stringify(persisted2);
+        const mainRow2 = {
+          id,
+          versionId: versionId2,
+          content: content2,
+          lastUpdated: now2,
+          deleted: 0,
+          _source: persisted2.meta?.source ?? null,
+          _profile: persisted2.meta?.profile ? JSON.stringify(persisted2.meta.profile) : null,
+          ...indexResult2.searchColumns
+        };
+        const historyRow2 = { id, versionId: versionId2, content: content2, lastUpdated: now2, deleted: 0 };
+        await this.adapter.transaction(async (tx) => {
+          const updateSQL = buildUpdateMainSQLv2(resourceType, mainRow2);
+          await tx.execute(updateSQL.sql, updateSQL.values);
+          const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow2);
+          await tx.execute(histSQL.sql, histSQL.values);
+        });
+        return { resource: persisted2, created: true };
+      }
       throw new ResourceGoneError(resourceType, id);
     }
     if (options?.ifMatch) {
@@ -6926,7 +7058,7 @@ var FhirPersistence = class {
       const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
       await tx.execute(histSQL.sql, histSQL.values);
     });
-    return persisted;
+    return { resource: persisted, created: false };
   }
   // ---------------------------------------------------------------------------
   // DELETE (soft)
@@ -6995,6 +7127,24 @@ var FhirPersistence = class {
     }));
   }
   // ---------------------------------------------------------------------------
+  // TYPE-LEVEL HISTORY (PERS-06)
+  // ---------------------------------------------------------------------------
+  async readTypeHistory(resourceType, options) {
+    const { sql, values } = buildTypeHistorySQLv2(
+      `${resourceType}_History`,
+      options
+    );
+    const rows = await this.adapter.query(sql, values);
+    return rows.map((row) => ({
+      id: row.id,
+      versionId: row.versionId,
+      lastUpdated: row.lastUpdated,
+      deleted: row.deleted === 1,
+      resourceType,
+      resource: row.deleted === 1 ? null : JSON.parse(row.content)
+    }));
+  }
+  // ---------------------------------------------------------------------------
   // SEARCH (streaming)
   // ---------------------------------------------------------------------------
   /**
@@ -7045,6 +7195,636 @@ var FhirPersistence = class {
   }
 };
 
+// src/store/conditional-service.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+var ConditionalService = class {
+  constructor(adapter, registry) {
+    this.adapter = adapter;
+    this.registry = registry;
+  }
+  // ---------------------------------------------------------------------------
+  // conditionalCreate (If-None-Exist)
+  // ---------------------------------------------------------------------------
+  /**
+   * Conditional create: search for existing matches, create only if none found.
+   *
+   * - 0 matches → create new resource
+   * - 1 match → return existing resource (no-op)
+   * - 2+ matches → PreconditionFailedError
+   *
+   * @param resourceType - FHIR resource type
+   * @param resource - The resource to create
+   * @param searchParams - Search criteria (If-None-Exist)
+   */
+  async conditionalCreate(resourceType, resource, searchParams) {
+    const matches = await this.searchMatches(resourceType, searchParams, 2);
+    if (matches.length > 1) {
+      throw new PreconditionFailedError(resourceType, matches.length);
+    }
+    if (matches.length === 1) {
+      return {
+        outcome: "existing",
+        resource: JSON.parse(matches[0].content)
+      };
+    }
+    const persisted = await this.createInTransaction(resourceType, resource);
+    return { outcome: "created", resource: persisted };
+  }
+  // ---------------------------------------------------------------------------
+  // conditionalUpdate (search-based PUT)
+  // ---------------------------------------------------------------------------
+  /**
+   * Conditional update: search for matches, update if exactly one found.
+   *
+   * - 0 matches → create new resource
+   * - 1 match → update existing resource
+   * - 2+ matches → PreconditionFailedError
+   *
+   * @param resourceType - FHIR resource type
+   * @param resource - The resource to create/update
+   * @param searchParams - Search criteria
+   */
+  async conditionalUpdate(resourceType, resource, searchParams) {
+    const matches = await this.searchMatches(resourceType, searchParams, 2);
+    if (matches.length > 1) {
+      throw new PreconditionFailedError(resourceType, matches.length);
+    }
+    if (matches.length === 0) {
+      const persisted2 = await this.createInTransaction(resourceType, resource);
+      return { outcome: "created", resource: persisted2 };
+    }
+    const existing = matches[0];
+    const persisted = await this.updateInTransaction(
+      resourceType,
+      resource,
+      existing.id
+    );
+    return { outcome: "updated", resource: persisted };
+  }
+  // ---------------------------------------------------------------------------
+  // conditionalDelete
+  // ---------------------------------------------------------------------------
+  /**
+   * Conditional delete: delete all resources matching the search criteria.
+   *
+   * @param resourceType - FHIR resource type
+   * @param searchParams - Search criteria
+   * @returns Number of resources deleted
+   */
+  async conditionalDelete(resourceType, searchParams) {
+    const matches = await this.searchMatches(resourceType, searchParams, 1e3);
+    if (matches.length === 0) {
+      return { count: 0 };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.adapter.transaction(async (tx) => {
+      for (const match of matches) {
+        const versionId = randomUUID5();
+        const deleteRow = {
+          id: match.id,
+          versionId,
+          content: match.content,
+          lastUpdated: now,
+          deleted: 1
+        };
+        const historyRow = {
+          id: match.id,
+          versionId,
+          content: match.content,
+          lastUpdated: now,
+          deleted: 1
+        };
+        const updateSQL = buildUpdateMainSQLv2(resourceType, deleteRow);
+        await tx.execute(updateSQL.sql, updateSQL.values);
+        const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
+        await tx.execute(histSQL.sql, histSQL.values);
+      }
+    });
+    return { count: matches.length };
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Search for matches
+  // ---------------------------------------------------------------------------
+  async searchMatches(resourceType, searchParams, limit) {
+    const searchSQL = buildSearchSQLv2(
+      {
+        resourceType,
+        params: searchParams,
+        count: limit
+      },
+      this.registry
+    );
+    return this.adapter.query(
+      searchSQL.sql,
+      searchSQL.values
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Create in transaction
+  // ---------------------------------------------------------------------------
+  async createInTransaction(resourceType, resource) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = resource.id ?? randomUUID5();
+    const versionId = randomUUID5();
+    const persisted = {
+      ...resource,
+      resourceType,
+      id,
+      meta: {
+        ...resource.meta,
+        versionId,
+        lastUpdated: now
+      }
+    };
+    const content = JSON.stringify(persisted);
+    const mainRow = {
+      id,
+      versionId,
+      content,
+      lastUpdated: now,
+      deleted: 0
+    };
+    const historyRow = {
+      id,
+      versionId,
+      content,
+      lastUpdated: now,
+      deleted: 0
+    };
+    await this.adapter.transaction(async (tx) => {
+      const mainSQL = buildInsertMainSQLv2(resourceType, mainRow);
+      await tx.execute(mainSQL.sql, mainSQL.values);
+      const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
+      await tx.execute(histSQL.sql, histSQL.values);
+    });
+    return persisted;
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Update in transaction
+  // ---------------------------------------------------------------------------
+  async updateInTransaction(resourceType, resource, existingId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const versionId = randomUUID5();
+    const persisted = {
+      ...resource,
+      resourceType,
+      id: existingId,
+      meta: {
+        ...resource.meta,
+        versionId,
+        lastUpdated: now
+      }
+    };
+    const content = JSON.stringify(persisted);
+    const mainRow = {
+      id: existingId,
+      versionId,
+      content,
+      lastUpdated: now,
+      deleted: 0
+    };
+    const historyRow = {
+      id: existingId,
+      versionId,
+      content,
+      lastUpdated: now,
+      deleted: 0
+    };
+    await this.adapter.transaction(async (tx) => {
+      const updateSQL = buildUpdateMainSQLv2(resourceType, mainRow);
+      await tx.execute(updateSQL.sql, updateSQL.values);
+      const histSQL = buildInsertHistorySQLv2(`${resourceType}_History`, historyRow);
+      await tx.execute(histSQL.sql, histSQL.values);
+    });
+    return persisted;
+  }
+};
+
+// src/transaction/urn-resolver.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+function buildUrnMap(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.request?.method === "POST" && entry.fullUrl?.startsWith("urn:uuid:") && entry.resource?.resourceType) {
+      const newId = randomUUID6();
+      map.set(entry.fullUrl, {
+        id: newId,
+        resourceType: entry.resource.resourceType
+      });
+    }
+  }
+  return map;
+}
+function deepResolveUrns(resource, urnMap) {
+  if (urnMap.size === 0) return resource;
+  const clone = structuredClone(resource);
+  const stack = [clone];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === null || current === void 0 || typeof current !== "object") {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        if (typeof item === "object" && item !== null) {
+          stack.push(item);
+        }
+      }
+      continue;
+    }
+    const record = current;
+    if (typeof record.reference === "string") {
+      const target = urnMap.get(record.reference);
+      if (target) {
+        record.reference = `${target.resourceType}/${target.id}`;
+      }
+    }
+    for (const key of Object.keys(record)) {
+      const value = record[key];
+      if (typeof value === "object" && value !== null) {
+        stack.push(value);
+      }
+    }
+  }
+  return clone;
+}
+
+// src/transaction/bundle-processor.ts
+function parseRequestUrl(url) {
+  const qIdx = url.indexOf("?");
+  let path = url;
+  let query;
+  if (qIdx !== -1) {
+    path = url.substring(0, qIdx);
+    query = url.substring(qIdx + 1);
+  }
+  const parts = path.split("/");
+  return { resourceType: parts[0], id: parts[1], query };
+}
+async function processTransactionV2(store, adapter, bundle) {
+  const entries = bundle.entry ?? [];
+  if (entries.length === 0) {
+    return { resourceType: "Bundle", type: "transaction-response", entry: [] };
+  }
+  const urnMap = buildUrnMap(entries);
+  try {
+    const responseEntries = await adapter.transaction(async (tx) => {
+      const results = [];
+      for (const entry of entries) {
+        const result = await processEntryInTransaction(tx, entry, urnMap);
+        results.push(result);
+      }
+      return results;
+    });
+    return {
+      resourceType: "Bundle",
+      type: "transaction-response",
+      entry: responseEntries
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      resourceType: "Bundle",
+      type: "transaction-response",
+      entry: [{
+        response: {
+          status: "500",
+          outcome: {
+            issue: [{ severity: "error", code: "exception", diagnostics: message }]
+          }
+        }
+      }]
+    };
+  }
+}
+async function processBatchV2(store, bundle) {
+  const entries = bundle.entry ?? [];
+  const responseEntries = [];
+  for (const entry of entries) {
+    if (entry.fullUrl?.startsWith("urn:uuid:")) {
+      responseEntries.push({
+        response: {
+          status: "400",
+          outcome: {
+            issue: [{ severity: "error", code: "invalid", diagnostics: "urn:uuid references are not allowed in batch mode" }]
+          }
+        }
+      });
+      continue;
+    }
+    try {
+      const result = await processBatchEntry(store, entry);
+      responseEntries.push(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const status = errorToStatus(err);
+      responseEntries.push({
+        response: {
+          status,
+          outcome: {
+            issue: [{ severity: "error", code: "exception", diagnostics: message }]
+          }
+        }
+      });
+    }
+  }
+  return {
+    resourceType: "Bundle",
+    type: "batch-response",
+    entry: responseEntries
+  };
+}
+async function processEntryInTransaction(tx, entry, urnMap) {
+  if (!entry.request) {
+    throw new Error("Missing request");
+  }
+  const { method, url } = entry.request;
+  const { resourceType, id } = parseRequestUrl(url);
+  switch (method) {
+    case "POST": {
+      if (!entry.resource) {
+        throw new Error("Missing resource for POST");
+      }
+      if (entry.request.ifNoneExist) {
+        const matchResult = await checkIfNoneExistInTx(tx, resourceType, entry.request.ifNoneExist);
+        if (matchResult.status !== "create") {
+          return matchResult.response;
+        }
+      }
+      const resolved = deepResolveUrns(entry.resource, urnMap);
+      let assignedId;
+      if (entry.fullUrl?.startsWith("urn:uuid:")) {
+        const target = urnMap.get(entry.fullUrl);
+        if (target) assignedId = target.id;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const { randomUUID: randomUUID7 } = __require("node:crypto");
+      const versionId = randomUUID7();
+      const finalId = assignedId ?? resolved.id ?? randomUUID7();
+      const persisted = {
+        ...resolved,
+        resourceType,
+        id: finalId,
+        meta: {
+          ...resolved.meta,
+          versionId,
+          lastUpdated: now
+        }
+      };
+      const content = JSON.stringify(persisted);
+      await tx.execute(
+        `INSERT INTO "${resourceType}" ("id", "versionId", "content", "lastUpdated", "deleted", "_source", "_profile") VALUES (?, ?, ?, ?, 0, ?, ?)`,
+        [finalId, versionId, content, now, persisted.meta?.source ?? null, persisted.meta?.profile ? JSON.stringify(persisted.meta.profile) : null]
+      );
+      await tx.execute(
+        `INSERT INTO "${resourceType}_History" ("id", "versionId", "content", "lastUpdated", "deleted") VALUES (?, ?, ?, ?, 0)`,
+        [finalId, versionId, content, now]
+      );
+      return {
+        resource: persisted,
+        response: {
+          status: "201",
+          location: `${resourceType}/${finalId}/_history/${versionId}`,
+          etag: `W/"${versionId}"`,
+          lastModified: now
+        }
+      };
+    }
+    case "PUT": {
+      if (!entry.resource) {
+        throw new Error("Missing resource for PUT");
+      }
+      if (!id) {
+        throw new Error("PUT requires resource ID in URL");
+      }
+      const resolved = deepResolveUrns(entry.resource, urnMap);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const { randomUUID: randomUUID7 } = __require("node:crypto");
+      const versionId = randomUUID7();
+      const persisted = {
+        ...resolved,
+        resourceType,
+        id,
+        meta: {
+          ...resolved.meta,
+          versionId,
+          lastUpdated: now
+        }
+      };
+      const content = JSON.stringify(persisted);
+      const existing = await tx.queryOne(
+        `SELECT "id", "deleted" FROM "${resourceType}" WHERE "id" = ?`,
+        [id]
+      );
+      if (existing) {
+        await tx.execute(
+          `UPDATE "${resourceType}" SET "versionId" = ?, "content" = ?, "lastUpdated" = ?, "deleted" = 0, "_source" = ?, "_profile" = ? WHERE "id" = ?`,
+          [versionId, content, now, persisted.meta?.source ?? null, persisted.meta?.profile ? JSON.stringify(persisted.meta.profile) : null, id]
+        );
+      } else {
+        await tx.execute(
+          `INSERT INTO "${resourceType}" ("id", "versionId", "content", "lastUpdated", "deleted", "_source", "_profile") VALUES (?, ?, ?, ?, 0, ?, ?)`,
+          [id, versionId, content, now, persisted.meta?.source ?? null, persisted.meta?.profile ? JSON.stringify(persisted.meta.profile) : null]
+        );
+      }
+      await tx.execute(
+        `INSERT INTO "${resourceType}_History" ("id", "versionId", "content", "lastUpdated", "deleted") VALUES (?, ?, ?, ?, 0)`,
+        [id, versionId, content, now]
+      );
+      return {
+        resource: persisted,
+        response: {
+          status: existing ? "200" : "201",
+          location: `${resourceType}/${id}/_history/${versionId}`,
+          etag: `W/"${versionId}"`,
+          lastModified: now
+        }
+      };
+    }
+    case "DELETE": {
+      if (!id) {
+        throw new Error("DELETE requires resource ID");
+      }
+      const existing = await tx.queryOne(
+        `SELECT "id", "content", "deleted" FROM "${resourceType}" WHERE "id" = ?`,
+        [id]
+      );
+      if (!existing || existing.deleted === 1) {
+        return { response: { status: "204" } };
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const { randomUUID: randomUUID7 } = __require("node:crypto");
+      const versionId = randomUUID7();
+      await tx.execute(
+        `UPDATE "${resourceType}" SET "versionId" = ?, "lastUpdated" = ?, "deleted" = 1 WHERE "id" = ?`,
+        [versionId, now, id]
+      );
+      await tx.execute(
+        `INSERT INTO "${resourceType}_History" ("id", "versionId", "content", "lastUpdated", "deleted") VALUES (?, ?, ?, ?, 1)`,
+        [id, versionId, existing.content, now]
+      );
+      await tx.execute(
+        `DELETE FROM "${resourceType}_References" WHERE "resourceId" = ?`,
+        [id]
+      );
+      return { response: { status: "204" } };
+    }
+    case "GET": {
+      if (!id) {
+        throw new Error("GET requires resource ID");
+      }
+      const row = await tx.queryOne(
+        `SELECT "content", "deleted" FROM "${resourceType}" WHERE "id" = ?`,
+        [id]
+      );
+      if (!row) {
+        throw new ResourceNotFoundError(resourceType, id);
+      }
+      if (row.deleted === 1) {
+        throw new ResourceGoneError(resourceType, id);
+      }
+      const resource = JSON.parse(row.content);
+      return { resource, response: { status: "200" } };
+    }
+    default:
+      throw new Error(`Unsupported method: ${method}`);
+  }
+}
+async function checkIfNoneExistInTx(tx, resourceType, ifNoneExist) {
+  const params = new URLSearchParams(ifNoneExist);
+  const conditions = [];
+  const values = [];
+  for (const [key, value] of params.entries()) {
+    if (key === "_id") {
+      conditions.push('"id" = ?');
+      values.push(value);
+    } else if (key === "identifier") {
+      conditions.push('"content" LIKE ?');
+      values.push(`%${value}%`);
+    } else {
+      conditions.push(`"${key}" = ?`);
+      values.push(value);
+    }
+  }
+  if (conditions.length === 0) {
+    return { status: "create" };
+  }
+  const whereClause = conditions.join(" AND ");
+  const rows = await tx.query(
+    `SELECT "id", "content", "versionId", "lastUpdated" FROM "${resourceType}" WHERE "deleted" = 0 AND ${whereClause}`,
+    values
+  );
+  if (rows.length === 0) {
+    return { status: "create" };
+  }
+  if (rows.length === 1) {
+    const existing = JSON.parse(rows[0].content);
+    return {
+      status: "existing",
+      response: {
+        resource: existing,
+        response: {
+          status: "200",
+          location: `${resourceType}/${rows[0].id}/_history/${rows[0].versionId}`,
+          etag: `W/"${rows[0].versionId}"`,
+          lastModified: rows[0].lastUpdated
+        }
+      }
+    };
+  }
+  return {
+    status: "error",
+    response: {
+      response: {
+        status: "412",
+        outcome: {
+          issue: [{
+            severity: "error",
+            code: "duplicate",
+            diagnostics: `If-None-Exist matched ${rows.length} resources for ${resourceType}`
+          }]
+        }
+      }
+    }
+  };
+}
+async function processBatchEntry(store, entry) {
+  if (!entry.request) {
+    return errorResponse("400", "Missing request");
+  }
+  const { method, url } = entry.request;
+  const { resourceType, id } = parseRequestUrl(url);
+  switch (method) {
+    case "POST": {
+      if (!entry.resource) {
+        return errorResponse("400", "Missing resource for POST");
+      }
+      const created = await store.createResource(resourceType, entry.resource);
+      const versionId = created.meta?.versionId ?? "";
+      const lastUpdated = created.meta?.lastUpdated ?? "";
+      return {
+        resource: created,
+        response: {
+          status: "201",
+          location: `${resourceType}/${created.id}/_history/${versionId}`,
+          etag: `W/"${versionId}"`,
+          lastModified: lastUpdated
+        }
+      };
+    }
+    case "PUT": {
+      if (!entry.resource || !id) {
+        return errorResponse("400", "PUT requires resource and ID");
+      }
+      const toUpdate = { ...entry.resource, id };
+      const updateResult = await store.updateResource(resourceType, toUpdate, { upsert: true });
+      const updated = updateResult.resource;
+      const versionId = updated.meta?.versionId ?? "";
+      const lastUpdated = updated.meta?.lastUpdated ?? "";
+      return {
+        resource: updated,
+        response: {
+          status: updateResult.created ? "201" : "200",
+          location: `${resourceType}/${id}/_history/${versionId}`,
+          etag: `W/"${versionId}"`,
+          lastModified: lastUpdated
+        }
+      };
+    }
+    case "DELETE": {
+      if (!id) {
+        return errorResponse("400", "DELETE requires resource ID");
+      }
+      await store.deleteResource(resourceType, id);
+      return { response: { status: "204" } };
+    }
+    case "GET": {
+      if (!id) {
+        return errorResponse("400", "GET requires resource ID");
+      }
+      const resource = await store.readResource(resourceType, id);
+      return { resource, response: { status: "200" } };
+    }
+    default:
+      return errorResponse("400", `Unsupported method: ${method}`);
+  }
+}
+function errorResponse(status, message) {
+  return {
+    response: {
+      status,
+      outcome: {
+        issue: [{ severity: "error", code: "processing", diagnostics: message }]
+      }
+    }
+  };
+}
+function errorToStatus(err) {
+  if (err instanceof ResourceNotFoundError) return "404";
+  if (err instanceof ResourceGoneError) return "410";
+  return "500";
+}
+
 // src/migration/schema-diff.ts
 function compareSchemas(oldSets, newSets) {
   const deltas = [];
@@ -9501,6 +10281,7 @@ var IGImportOrchestrator = class {
 export {
   BetterSqlite3Adapter,
   ConceptHierarchyRepo,
+  ConditionalService,
   DEFAULT_SEARCH_COUNT,
   DELETED_SCHEMA_VERSION,
   ElementIndexRepo,
@@ -9567,10 +10348,12 @@ export {
   buildTwoPhaseSearchSQLv2,
   buildTypeHistorySQLv2,
   buildUpdateMainSQLv2,
+  buildUrnMap,
   buildWhereClauseV2,
   buildWhereFragmentV2,
   compareSchemas,
   createFhirRuntimeProvider,
+  deepResolveUrns,
   executeSearchV2 as executeSearch,
   extractPrefix,
   extractPropertyPath,
@@ -9593,6 +10376,8 @@ export {
   parseSortParam,
   planSearch,
   prefixToOperator,
+  processBatchV2,
+  processTransactionV2,
   reindexAllV2,
   reindexResourceTypeV2,
   splitSearchValues