@openhi/constructs 0.0.138 → 0.0.140

package/lib/rest-api-lambda.handler.mjs

@@ -5405,6 +5405,89 @@ async function listAppointmentsOperation(params) {
   );
 }
 
+// src/data/search/engine/reference-predicate.ts
+function buildOpenHiResourceUrn(opts) {
+  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
+}
+var REFERENCE_CONTAINMENT_SQL_FRAGMENT = "(resource @> :containmentRelative::jsonb OR resource @> :containmentUrn::jsonb)";
+function parseTypedReference(s) {
+  const match = /^([A-Za-z][A-Za-z0-9_]*)\/([^\s/]+)$/.exec(s);
+  if (!match) {
+    return void 0;
+  }
+  return { resourceType: match[1], resourceId: match[2] };
+}
+function wrapReferenceInShape(shape, reference) {
+  switch (shape.kind) {
+    case "scalar":
+      return { [shape.field]: { reference } };
+    case "array-of-references":
+      return { [shape.field]: [{ reference }] };
+    case "array-of-objects":
+      return { [shape.field]: [{ [shape.subfield]: { reference } }] };
+  }
+}
+function buildReferenceContainmentPayload(params) {
+  const parsed = parseTypedReference(params.reference);
+  if (!parsed) {
+    throw new Error(
+      `Reference "${params.reference}" is not a valid typed reference (<ResourceType>/<id>).`
+    );
+  }
+  const urn = buildOpenHiResourceUrn({
+    tenantId: params.tenantId,
+    workspaceId: params.workspaceId,
+    resourceType: parsed.resourceType,
+    resourceId: parsed.resourceId
+  });
+  return {
+    containmentRelative: JSON.stringify(
+      wrapReferenceInShape(params.shape, params.reference)
+    ),
+    containmentUrn: JSON.stringify(wrapReferenceInShape(params.shape, urn))
+  };
+}
+function jsonbPathToReferenceShape(jsonbPath) {
+  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (scalar) {
+    return { kind: "scalar", field: scalar[1] };
+  }
+  const arrayOfRefs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfRefs) {
+    return { kind: "array-of-references", field: arrayOfRefs[1] };
+  }
+  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
+    jsonbPath
+  );
+  if (arrayOfObjs) {
+    return {
+      kind: "array-of-objects",
+      field: arrayOfObjs[1],
+      subfield: arrayOfObjs[2]
+    };
+  }
+  throw new Error(
+    `Reference predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
+  );
+}
+function emitReferencePredicate(opts) {
+  const shape = jsonbPathToReferenceShape(opts.jsonbPath);
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape,
+    reference: opts.rawValue,
+    tenantId: opts.context.tenantId,
+    workspaceId: opts.context.workspaceId
+  });
+  const relName = `${opts.paramName}R`;
+  const urnName = `${opts.paramName}U`;
+  const sql = `(resource @> :${relName}::jsonb OR resource @> :${urnName}::jsonb)`;
+  const params = [
+    { name: relName, value: containmentRelative },
+    { name: urnName, value: containmentUrn }
+  ];
+  return { sql, params };
+}
+
 // src/data/postgres/data-api-postgres-query-runner.ts
 import {
   ExecuteStatementCommand,
@@ -5596,129 +5679,95 @@ function emitFieldMissingPredicate(opts) {
   const sql = opts.missing ? `${extract} IS NULL` : `${extract} IS NOT NULL`;
   return { sql, params: [] };
 }
-var DEFAULT_INTERVAL_PARAM_PREFIX = "intervalDateConstraint";
-function intervalConstraintParamName(prefix, index) {
-  return `${prefix}${index}`;
+
+// src/data/search/engine/string-predicate.ts
+var STRING_MODIFIERS = ["exact", "contains"];
+function isStringModifier(s) {
+  return STRING_MODIFIERS.includes(s);
 }
-function buildIntervalSingleSql(prefix, startExtract, endExtract, paramName) {
-  switch (prefix) {
-    case "eq":
-      return `(${startExtract} IS NOT NULL AND ${startExtract} = :${paramName})`;
-    case "gt":
-      return `(${endExtract} IS NULL OR ${endExtract} > :${paramName})`;
-    case "lt":
-      return `(${startExtract} IS NULL OR ${startExtract} < :${paramName})`;
-    case "ge":
-      return `(${endExtract} IS NULL OR ${endExtract} >= :${paramName})`;
-    case "le":
-      return `(${startExtract} IS NULL OR ${startExtract} <= :${paramName})`;
-    case "sa":
-      return `(${startExtract} IS NOT NULL AND ${startExtract} > :${paramName})`;
-    case "eb":
-      return `(${endExtract} IS NOT NULL AND ${endExtract} < :${paramName})`;
+function jsonbPathToStringShape(jsonbPath) {
+  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
+  if (scalar) {
+    return { kind: "scalar", field: scalar[1] };
   }
-}
-function buildIntervalDateSearchPredicateSql(constraints, opts) {
-  if (constraints.length === 0) {
-    return [];
+  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfScalars) {
+    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
   }
-  const paramPrefix = opts.paramNamePrefix ?? DEFAULT_INTERVAL_PARAM_PREFIX;
-  const startExtract = flatJsonbExtract(opts.startPath);
-  const endExtract = flatJsonbExtract(opts.endPath);
-  const fragments = constraints.map(
-    (c, i) => buildIntervalSingleSql(
-      c.prefix,
-      startExtract,
-      endExtract,
-      intervalConstraintParamName(paramPrefix, i)
-    )
+  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
+    jsonbPath
   );
-  fragments.push(`(${startExtract} IS NOT NULL OR ${endExtract} IS NOT NULL)`);
-  return fragments;
-}
-function buildIntervalDateSearchPredicateParams(constraints, opts) {
-  const paramPrefix = opts?.paramNamePrefix ?? DEFAULT_INTERVAL_PARAM_PREFIX;
-  return constraints.map((c, i) => ({
-    name: intervalConstraintParamName(paramPrefix, i),
-    value: c.value
-  }));
-}
-var APPOINTMENT_DATE_SEARCH_PREFIXES = [
-  "gt",
-  "lt",
-  "ge",
-  "le",
-  "sa",
-  "eb"
-];
-function isAppointmentDateSearchPrefix(s) {
-  return APPOINTMENT_DATE_SEARCH_PREFIXES.includes(
-    s
+  if (arrayOfObjs) {
+    return {
+      kind: "array-of-objects",
+      field: arrayOfObjs[1],
+      subfield: arrayOfObjs[2]
+    };
+  }
+  throw new Error(
+    `String predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
   );
 }
-function buildAppointmentDateSearchPredicateSql(constraints) {
-  return buildIntervalDateSearchPredicateSql(constraints, {
-    startPath: "$.start",
-    endPath: "$.end",
-    paramNamePrefix: "apptDateConstraint"
-  });
-}
-function buildAppointmentDateSearchPredicateParams(constraints) {
-  return buildIntervalDateSearchPredicateParams(constraints, {
-    paramNamePrefix: "apptDateConstraint"
-  });
-}
-
-// src/data/search/engine/reference-predicate.ts
-function buildOpenHiResourceUrn(opts) {
-  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
+function escapeLikePattern(value) {
+  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
-var REFERENCE_CONTAINMENT_SQL_FRAGMENT = "(resource @> :containmentRelative::jsonb OR resource @> :containmentUrn::jsonb)";
-function parseTypedReference(s) {
-  const match = /^([A-Za-z][A-Za-z0-9_]*)\/([^\s/]+)$/.exec(s);
-  if (!match) {
-    return void 0;
+function buildLikePattern(value, modifier) {
+  const escaped = escapeLikePattern(value);
+  switch (modifier) {
+    case "exact":
+      return escaped;
+    case "contains":
+      return `%${escaped}%`;
+    case void 0:
+      return `${escaped}%`;
   }
-  return { resourceType: match[1], resourceId: match[2] };
 }
-function wrapReferenceInShape(shape, reference) {
+function buildIlikeExtractSql(shape, paramName) {
   switch (shape.kind) {
     case "scalar":
-      return { [shape.field]: { reference } };
-    case "array-of-references":
-      return { [shape.field]: [{ reference }] };
+      return `resource->>'${shape.field}' ILIKE :${paramName}`;
+    case "array-of-scalars":
+      return [
+        "EXISTS (SELECT 1 FROM",
+        `jsonb_array_elements_text(resource->'${shape.field}') AS s_elem(text_val)`,
+        `WHERE s_elem.text_val ILIKE :${paramName})`
+      ].join(" ");
     case "array-of-objects":
-      return { [shape.field]: [{ [shape.subfield]: { reference } }] };
+      return [
+        "EXISTS (SELECT 1 FROM",
+        `jsonb_array_elements(resource->'${shape.field}') AS s_obj(obj)`,
+        `WHERE s_obj.obj->>'${shape.subfield}' ILIKE :${paramName})`
+      ].join(" ");
   }
 }
-function buildReferenceContainmentPayload(params) {
-  const parsed = parseTypedReference(params.reference);
-  if (!parsed) {
+function emitStringPredicate(opts) {
+  const shape = jsonbPathToStringShape(opts.jsonbPath);
+  const modifier = opts.modifier === void 0 ? void 0 : checkModifier(opts.modifier);
+  const sql = buildIlikeExtractSql(shape, opts.paramName);
+  const pattern = buildLikePattern(opts.rawValue, modifier);
+  const params = [
+    { name: opts.paramName, value: pattern }
+  ];
+  return { sql, params };
+}
+function checkModifier(modifier) {
+  if (!isStringModifier(modifier)) {
     throw new Error(
-      `Reference "${params.reference}" is not a valid typed reference (<ResourceType>/<id>).`
+      `String predicate does not support modifier ":${modifier}". Supported: ${STRING_MODIFIERS.map((m) => `:${m}`).join(", ")}.`
     );
   }
-  const urn = buildOpenHiResourceUrn({
-    tenantId: params.tenantId,
-    workspaceId: params.workspaceId,
-    resourceType: parsed.resourceType,
-    resourceId: parsed.resourceId
-  });
-  return {
-    containmentRelative: JSON.stringify(
-      wrapReferenceInShape(params.shape, params.reference)
-    ),
-    containmentUrn: JSON.stringify(wrapReferenceInShape(params.shape, urn))
-  };
+  return modifier;
 }
-function jsonbPathToReferenceShape(jsonbPath) {
+
+// src/data/search/engine/token-predicate.ts
+function jsonbPathToTokenShape(jsonbPath) {
   const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
   if (scalar) {
     return { kind: "scalar", field: scalar[1] };
   }
-  const arrayOfRefs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfRefs) {
-    return { kind: "array-of-references", field: arrayOfRefs[1] };
+  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
+  if (arrayOfScalars) {
+    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
   }
   const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
     jsonbPath
@@ -5731,240 +5780,332 @@ function jsonbPathToReferenceShape(jsonbPath) {
     };
   }
   throw new Error(
-    `Reference predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
+    `Token predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
   );
 }
-function emitReferencePredicate(opts) {
-  const shape = jsonbPathToReferenceShape(opts.jsonbPath);
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape,
-    reference: opts.rawValue,
-    tenantId: opts.context.tenantId,
-    workspaceId: opts.context.workspaceId
-  });
-  const relName = `${opts.paramName}R`;
-  const urnName = `${opts.paramName}U`;
-  const sql = `(resource @> :${relName}::jsonb OR resource @> :${urnName}::jsonb)`;
+function parseTokenValue(raw) {
+  const idx = raw.indexOf("|");
+  if (idx === -1) {
+    return { code: raw };
+  }
+  const system = raw.slice(0, idx);
+  const code = raw.slice(idx + 1);
+  return system.length > 0 ? { system, code } : { code };
+}
+function wrapTokenInShape(shape, value) {
+  switch (shape.kind) {
+    case "scalar":
+      return { [shape.field]: value };
+    case "array-of-scalars":
+      return { [shape.field]: [value] };
+    case "array-of-objects":
+      return { [shape.field]: [{ [shape.subfield]: value }] };
+  }
+}
+function emitTokenPredicate(opts) {
+  const shape = jsonbPathToTokenShape(opts.jsonbPath);
+  const { code } = parseTokenValue(opts.rawValue);
+  const payload = wrapTokenInShape(shape, code);
+  const sql = `resource @> :${opts.paramName}::jsonb`;
   const params = [
-    { name: relName, value: containmentRelative },
-    { name: urnName, value: containmentUrn }
+    { name: opts.paramName, value: JSON.stringify(payload) }
   ];
   return { sql, params };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-actor-operation.ts
-var DEFAULT_LIMIT = 100;
-function buildSearchAppointmentsByActorSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts?.dateConstraints ?? []
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`
-  ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
+// src/data/search/engine/combinator.ts
+function parseQueryKey(key) {
+  const idx = key.indexOf(":");
+  if (idx === -1) {
+    return { code: key, modifier: void 0 };
   }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
+  return { code: key.slice(0, idx), modifier: key.slice(idx + 1) };
 }
-async function searchAppointmentsByActorOperation(params) {
-  const { context, actorReference } = params;
-  const dateConstraints = params.dateConstraints ?? [];
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: {
-      kind: "array-of-objects",
-      field: "participant",
-      subfield: "actor"
-    },
-    reference: actorReference,
-    tenantId,
-    workspaceId
+function flattenQueryValues(raw) {
+  const list = Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const v of list) {
+    for (const piece of v.split(",")) {
+      out.push(piece);
+    }
+  }
+  return out;
+}
+function parseQueryEntries(query) {
+  const entries = [];
+  for (const [rawKey, rawValue] of Object.entries(query)) {
+    if (rawValue === void 0) continue;
+    const { code, modifier } = parseQueryKey(rawKey);
+    entries.push({
+      code,
+      modifier,
+      values: flattenQueryValues(rawValue)
+    });
+  }
+  return entries;
+}
+function findParam(params, code) {
+  return params.find((p) => p.code === code);
+}
+function checkModifierAllowed(modifier, param) {
+  const universal = modifier === "missing" || modifier === "not";
+  const stringNative = param.type === "string" && (modifier === "exact" || modifier === "contains");
+  if (universal || stringNative) {
+    if (param.modifiers && !param.modifiers.includes(modifier)) {
+      throw new Error(
+        `Modifier ":${modifier}" is not in the allow-list for param "${param.code}".`
+      );
+    }
+    return;
+  }
+  throw new Error(
+    `Modifier ":${modifier}" is not recognized for param "${param.code}" (type "${param.type}").`
+  );
+}
+function emitOne(opts) {
+  const { param, modifier, rawValue, paramName, context } = opts;
+  if (modifier === "missing") {
+    const missing = parseMissingValue(rawValue);
+    return emitFieldMissingPredicate({
+      jsonbPath: param.jsonbPath,
+      missing
+    });
+  }
+  const negate = modifier === "not";
+  const effectiveModifier = negate ? void 0 : modifier;
+  const inner = emitForType({
+    paramType: param.type,
+    jsonbPath: param.jsonbPath,
+    rawValue,
+    paramName,
+    modifier: effectiveModifier,
+    context
   });
-  const sql = buildSearchAppointmentsByActorSql({ dateConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
+  if (!negate) {
+    return inner;
+  }
+  return { sql: `NOT (${inner.sql})`, params: inner.params };
+}
+function parseMissingValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  throw new Error(
+    `:missing requires a value of "true" or "false"; received "${raw}".`
+  );
+}
+function emitForType(opts) {
+  switch (opts.paramType) {
+    case "token":
+      return emitTokenPredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "date":
+      return emitDatePredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "reference":
+      return emitReferencePredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        context: opts.context
+      });
+    case "string":
+      return emitStringPredicate({
+        jsonbPath: opts.jsonbPath,
+        rawValue: opts.rawValue,
+        paramName: opts.paramName,
+        modifier: opts.modifier,
+        context: opts.context
+      });
+  }
+}
+function combineSearchPredicates(opts) {
+  const entries = parseQueryEntries(opts.query);
+  const groupSqls = [];
+  const allParams = [];
+  let paramIdx = 0;
+  for (const entry of entries) {
+    const registered = findParam(opts.registeredParams, entry.code);
+    if (!registered) {
+      continue;
     }
-  }));
-  return { entries, total: entries.length };
+    if (entry.modifier !== void 0) {
+      checkModifierAllowed(entry.modifier, registered);
+    }
+    if (entry.values.length === 0) {
+      continue;
+    }
+    const fragmentSqls = [];
+    let valueIdx = 0;
+    for (const rawValue of entry.values) {
+      const paramName = `p${paramIdx}v${valueIdx}`;
+      const frag = emitOne({
+        param: registered,
+        modifier: entry.modifier,
+        rawValue,
+        paramName,
+        context: opts.context
+      });
+      fragmentSqls.push(frag.sql);
+      for (const p of frag.params) {
+        allParams.push(p);
+      }
+      valueIdx++;
+    }
+    paramIdx++;
+    if (fragmentSqls.length === 1) {
+      groupSqls.push(fragmentSqls[0]);
+    } else {
+      groupSqls.push(`(${fragmentSqls.join(" OR ")})`);
+    }
+  }
+  if (groupSqls.length === 0) {
+    return { sql: "", params: [] };
+  }
+  return { sql: groupSqls.join(" AND "), params: allParams };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-date-operation.ts
-var DEFAULT_LIMIT2 = 100;
-function buildSearchAppointmentsByDateSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts.dateConstraints
-  );
+// src/data/search/operations/generic-search-operation.ts
+var DEFAULT_LIMIT = 100;
+function buildGenericSearchSql(opts) {
   const lines = [
     "SELECT resource_id AS id, resource",
     "FROM resources",
     "WHERE tenant_id = :tenantId",
     "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
+    "  AND resource_type = :resourceType",
     "  AND deleted_at IS NULL"
   ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
+  if (opts.combinedSql.length > 0) {
+    lines.push(`  AND (${opts.combinedSql})`);
   }
   lines.push("ORDER BY last_updated DESC");
   lines.push("LIMIT :limit;");
   return lines.join("\n");
 }
-async function searchAppointmentsByDateOperation(params) {
-  const { context, dateConstraints } = params;
-  if (dateConstraints.length === 0) {
-    throw new Error(
-      "searchAppointmentsByDateOperation requires at least one dateConstraint"
-    );
-  }
-  const { tenantId, workspaceId } = context;
+async function genericSearchOperation(params) {
+  const { resourceType, tenantId, workspaceId, query, resolver } = params;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT2;
-  const sql = buildSearchAppointmentsByDateSql({ dateConstraints });
+  const limit = params.limit ?? DEFAULT_LIMIT;
+  const registeredParams = resolver(resourceType, tenantId);
+  const context = { tenantId, workspaceId, resourceType };
+  const combined = combineSearchPredicates({
+    query,
+    registeredParams,
+    context
+  });
+  const sql = buildGenericSearchSql({ combinedSql: combined.sql });
   const queryParams = [
     { name: "tenantId", value: tenantId },
     { name: "workspaceId", value: workspaceId },
+    { name: "resourceType", value: resourceType },
     { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
+    ...combined.params
   ];
   const rows = await runner.query(sql, queryParams);
   const entries = rows.map((row) => ({
     id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
-    }
+    resource: { ...row.resource, id: row.id }
   }));
   return { entries, total: entries.length };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-patient-operation.ts
-var DEFAULT_LIMIT3 = 100;
-function buildSearchAppointmentsByPatientSql(opts) {
-  const datePredicates = buildAppointmentDateSearchPredicateSql(
-    opts?.dateConstraints ?? []
-  );
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Appointment'",
-    "  AND deleted_at IS NULL",
-    "  AND (resource @> :containmentRelative::jsonb",
-    "    OR resource @> :containmentUrn::jsonb)"
-  ];
-  for (const fragment of datePredicates) {
-    lines.push(`  AND ${fragment}`);
-  }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
-}
-async function searchAppointmentsByPatientOperation(params) {
-  const { context, patientId } = params;
-  const dateConstraints = params.dateConstraints ?? [];
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT3;
-  const containmentRelative = JSON.stringify({
-    participant: [{ actor: { reference: `Patient/${patientId}` } }]
-  });
-  const containmentUrn = JSON.stringify({
-    participant: [
-      {
-        actor: {
-          reference: buildOpenHiResourceUrn({
-            tenantId,
-            workspaceId,
-            resourceType: "Patient",
-            resourceId: patientId
-          })
-        }
-      }
-    ]
-  });
-  const sql = buildSearchAppointmentsByPatientSql({ dateConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit },
-    ...buildAppointmentDateSearchPredicateParams(dateConstraints)
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: {
-      ...row.resource,
-      id: row.id
-    }
-  }));
-  return { entries, total: entries.length };
-}
+// src/data/search/registry/appointment-search-parameters.ts
+var APPOINTMENT_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "date", type: "date", jsonbPath: "$.start" },
+  {
+    code: "patient",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  {
+    code: "actor",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  {
+    code: "practitioner",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  { code: "service-type", type: "token", jsonbPath: "$.serviceType[*]" },
+  {
+    code: "service-category",
+    type: "token",
+    jsonbPath: "$.serviceCategory[*]"
+  },
+  { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" },
+  {
+    code: "appointment-type",
+    type: "token",
+    jsonbPath: "$.appointmentType"
+  },
+  { code: "slot", type: "reference", jsonbPath: "$.slot[*]" }
+];
 
-// src/data/rest-api/routes/data/appointment/appointment-list-route.ts
-function singleStringQueryParam(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    return void 0;
+// src/data/search/registry/patient-search-parameters.ts
+var PATIENT_SEARCH_PARAMETERS = [
+  { code: "gender", type: "token", jsonbPath: "$.gender" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
+  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "family",
+    type: "string",
+    jsonbPath: "$.name[*].family",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "given",
+    type: "string",
+    jsonbPath: "$.name[*].given",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
+  {
+    code: "general-practitioner",
+    type: "reference",
+    jsonbPath: "$.generalPractitioner[*]"
+  },
+  {
+    code: "organization",
+    type: "reference",
+    jsonbPath: "$.managingOrganization"
   }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
+];
+
+// src/data/search/registry/resolver.ts
+var STATIC_SEARCH_PARAMETER_MAP = {
+  Appointment: APPOINTMENT_SEARCH_PARAMETERS,
+  Patient: PATIENT_SEARCH_PARAMETERS
+};
+var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+function getRegisteredSearchParameters(resourceType) {
+  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
 }
-function isError(v) {
-  return v.error !== void 0;
+
+// src/data/rest-api/routes/data/appointment/appointment-list-route.ts
+var APPOINTMENT_RESOURCE_TYPE = "Appointment";
+function stripModifier(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
 }
-function parseAppointmentDateConstraints(req) {
-  const raw = req.query.date;
-  if (raw === void 0) {
-    return [];
-  }
-  const values = Array.isArray(raw) ? raw : [raw];
-  const out = [];
-  for (const v of values) {
-    if (typeof v !== "string") {
-      return { error: "Each ?date= value must be a string." };
-    }
-    const trimmed = v.trim();
-    if (trimmed === "") {
-      return { error: "?date= value must not be empty." };
-    }
-    const prefix = trimmed.slice(0, 2);
-    const datetime = trimmed.slice(2);
-    if (!isAppointmentDateSearchPrefix(prefix)) {
-      return {
-        error: `Unsupported ?date= prefix in "${trimmed}". Supported prefixes: ${APPOINTMENT_DATE_SEARCH_PREFIXES.join(", ")}.`
-      };
-    }
-    if (datetime === "" || Number.isNaN(Date.parse(datetime))) {
-      return { error: `Invalid datetime in ?date=${trimmed}.` };
-    }
-    out.push({ prefix, value: datetime });
-  }
-  return out;
+function isResultParameter(key) {
+  return key.startsWith("_");
 }
 function sendInvalidSearch400(res, diagnostics) {
   return res.status(400).json({
@@ -5972,95 +6113,93 @@ function sendInvalidSearch400(res, diagnostics) {
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Appointment: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
 async function listAppointmentsRoute(req, res) {
-  const patientId = singleStringQueryParam(req, "patient");
-  const actorRef = singleStringQueryParam(req, "actor");
-  const parsed = parseAppointmentDateConstraints(req);
-  if (isError(parsed)) {
-    return sendInvalidSearch400(res, parsed.error);
+  const searchParamKeys = extractSearchParamKeys(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.APPOINTMENT,
+      listOperation: listAppointmentsOperation,
+      errorLogContext: "GET /Appointment list error:"
+    });
   }
-  const dateConstraints = parsed;
-  if (patientId !== void 0 && actorRef !== void 0) {
+  const registered = getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE);
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
     return sendInvalidSearch400(
       res,
-      "?patient= and ?actor= cannot be combined on the same request."
+      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
     );
   }
-  if (actorRef !== void 0) {
-    if (parseTypedReference(actorRef) === void 0) {
-      return sendInvalidSearch400(
-        res,
-        `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
-      );
-    }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByActorOperation({
-        context: ctx,
-        actorReference: actorRef,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?actor= search error:"
-      );
-    }
-  }
-  if (patientId !== void 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByPatientOperation({
-        context: ctx,
-        patientId,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?patient= search error:"
-      );
-    }
+  const malformedRef = findMalformedReference(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch400(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
   }
-  if (dateConstraints.length > 0) {
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchAppointmentsByDateOperation({
-        context: ctx,
-        dateConstraints
-      });
-      const bundle = buildSearchsetBundle(
-        BASE_PATH.APPOINTMENT,
-        result.entries
-      );
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Appointment?date= search error:"
-      );
-    }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: APPOINTMENT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.APPOINTMENT, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Appointment search error:");
   }
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.APPOINTMENT,
-    listOperation: listAppointmentsOperation,
-    errorLogContext: "GET /Appointment list error:"
-  });
 }
 
 // src/data/operations/data/appointment/appointment-update-operation.ts
@@ -13620,7 +13759,7 @@ function buildPeriodSearchPredicateParams(constraints) {
 }
 
 // src/data/operations/data/encounter/encounter-search-by-date-operation.ts
-var DEFAULT_LIMIT4 = 100;
+var DEFAULT_LIMIT2 = 100;
 function buildSearchEncountersByDateSql(opts) {
   const periodPredicates = buildPeriodSearchPredicateSql(
     opts.periodConstraints
@@ -13649,7 +13788,7 @@ async function searchEncountersByDateOperation(params) {
   }
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT4;
+  const limit = params.limit ?? DEFAULT_LIMIT2;
   const sql = buildSearchEncountersByDateSql({ periodConstraints });
   const queryParams = [
     { name: "tenantId", value: tenantId },
@@ -13669,7 +13808,7 @@ async function searchEncountersByDateOperation(params) {
 }
 
 // src/data/operations/data/encounter/encounter-search-by-participant-operation.ts
-var DEFAULT_LIMIT5 = 100;
+var DEFAULT_LIMIT3 = 100;
 function buildSearchEncountersByParticipantSql(opts) {
   const periodPredicates = buildPeriodSearchPredicateSql(
     opts?.periodConstraints ?? []
@@ -13695,7 +13834,7 @@ async function searchEncountersByParticipantOperation(params) {
   const periodConstraints = params.periodConstraints ?? [];
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT5;
+  const limit = params.limit ?? DEFAULT_LIMIT3;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: {
       kind: "array-of-objects",
@@ -13727,7 +13866,7 @@ async function searchEncountersByParticipantOperation(params) {
 }
 
 // src/data/operations/data/encounter/encounter-search-by-patient-operation.ts
-var DEFAULT_LIMIT6 = 100;
+var DEFAULT_LIMIT4 = 100;
 function buildSearchEncountersByPatientSql(opts) {
   const periodPredicates = buildPeriodSearchPredicateSql(
     opts?.periodConstraints ?? []
@@ -13754,7 +13893,7 @@ async function searchEncountersByPatientOperation(params) {
   const periodConstraints = params.periodConstraints ?? [];
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT6;
+  const limit = params.limit ?? DEFAULT_LIMIT4;
   const containmentRelative = JSON.stringify({
     subject: { reference: `Patient/${patientId}` }
   });
@@ -13789,7 +13928,7 @@ async function searchEncountersByPatientOperation(params) {
 }
 
 // src/data/rest-api/routes/data/encounter/encounter-list-route.ts
-function singleStringQueryParam2(req, name) {
+function singleStringQueryParam(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -13797,7 +13936,7 @@ function singleStringQueryParam2(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function isError2(v) {
+function isError(v) {
   return v.error !== void 0;
 }
 function parseEncounterDateConstraints(req) {
@@ -13836,10 +13975,10 @@ function sendInvalidSearch4002(res, diagnostics) {
   });
 }
 async function listEncountersRoute(req, res) {
-  const patientId = singleStringQueryParam2(req, "patient");
-  const participantRef = singleStringQueryParam2(req, "participant");
+  const patientId = singleStringQueryParam(req, "patient");
+  const participantRef = singleStringQueryParam(req, "participant");
   const parsed = parseEncounterDateConstraints(req);
-  if (isError2(parsed)) {
+  if (isError(parsed)) {
     return sendInvalidSearch4002(res, parsed.error);
   }
   const periodConstraints = parsed;
@@ -25412,560 +25551,177 @@ async function listOrganizationAffiliationsRoute(req, res) {
   return handleListRoute({
     req,
     res,
-    basePath: BASE_PATH.ORGANIZATIONAFFILIATION,
-    listOperation: listOrganizationAffiliationsOperation,
-    errorLogContext: "GET /OrganizationAffiliation list error:"
-  });
-}
-
-// src/data/operations/data/organizationaffiliation/organizationaffiliation-update-operation.ts
-async function updateOrganizationAffiliationOperation(params) {
-  const { context, id, body, tableName } = params;
-  const { tenantId, workspaceId, date, actorId, actorName } = context;
-  const service = getDynamoDataService(tableName);
-  return updateDataEntityById(
-    service.entities.organizationaffiliation,
-    tenantId,
-    workspaceId,
-    id,
-    "OrganizationAffiliation",
-    context,
-    (existingResourceStr) => buildUpdatedResourceWithAudit(
-      body,
-      id,
-      date,
-      actorId,
-      actorName,
-      existingResourceStr,
-      "OrganizationAffiliation"
-    )
-  );
-}
-
-// src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation-update-route.ts
-async function updateOrganizationAffiliationRoute(req, res) {
-  const bodyResult = requireJsonBodyAs(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  const body = bodyResult.body;
-  const resource = {
-    ...body,
-    resourceType: "OrganizationAffiliation",
-    id
-  };
-  try {
-    const result = await updateOrganizationAffiliationOperation({
-      context: ctx,
-      id,
-      body: resource
-    });
-    return res.json(result.resource);
-  } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `OrganizationAffiliation ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(
-      res,
-      err,
-      "PUT OrganizationAffiliation error:"
-    );
-  }
-}
-
-// src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation.ts
-var router107 = express107.Router();
-router107.get("/", listOrganizationAffiliationsRoute);
-router107.get("/:id", getOrganizationAffiliationByIdRoute);
-router107.post("/", createOrganizationAffiliationRoute);
-router107.put("/:id", updateOrganizationAffiliationRoute);
-router107.delete("/:id", deleteOrganizationAffiliationRoute);
-
-// src/data/rest-api/routes/data/patient/patient.ts
-import express108 from "express";
-
-// src/data/rest-api/routes/data/patient/patient-create-route.ts
-async function createPatientRoute(req, res) {
-  const bodyResult = requireJsonBodyAs(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
-  const ctx = req.openhiContext;
-  const body = bodyResult.body;
-  const patient = {
-    ...body,
-    resourceType: "Patient"
-  };
-  try {
-    const result = await createPatientOperation({
-      context: ctx,
-      body: patient
-    });
-    return res.status(201).location(`${BASE_PATH.PATIENT}/${result.id}`).json(result.resource);
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "POST Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-delete-operation.ts
-async function deletePatientOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  await deleteDataEntityById(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    id
-  );
-}
-
-// src/data/rest-api/routes/data/patient/patient-delete-route.ts
-async function deletePatientRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    await deletePatientOperation({ context: ctx, id });
-    return res.status(204).send();
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "DELETE Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-get-by-id-operation.ts
-async function getPatientByIdOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return getDataEntityById(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    id,
-    "Patient"
-  );
-}
-
-// src/data/rest-api/routes/data/patient/patient-get-by-id-route.ts
-async function getPatientByIdRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    const result = await getPatientByIdOperation({ context: ctx, id });
-    return res.json(result.resource);
-  } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "GET Patient error:");
-  }
-}
-
-// src/data/operations/data/patient/patient-list-operation.ts
-async function listPatientsOperation(params) {
-  const { context, tableName, mode } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return listDataEntitiesByWorkspace(
-    service.entities.patient,
-    tenantId,
-    workspaceId,
-    mode
-  );
-}
-
-// src/data/search/engine/string-predicate.ts
-var STRING_MODIFIERS = ["exact", "contains"];
-function isStringModifier(s) {
-  return STRING_MODIFIERS.includes(s);
-}
-function jsonbPathToStringShape(jsonbPath) {
-  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
-  if (scalar) {
-    return { kind: "scalar", field: scalar[1] };
-  }
-  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfScalars) {
-    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
-  }
-  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
-    jsonbPath
-  );
-  if (arrayOfObjs) {
-    return {
-      kind: "array-of-objects",
-      field: arrayOfObjs[1],
-      subfield: arrayOfObjs[2]
-    };
-  }
-  throw new Error(
-    `String predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
-  );
-}
-function escapeLikePattern(value) {
-  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-}
-function buildLikePattern(value, modifier) {
-  const escaped = escapeLikePattern(value);
-  switch (modifier) {
-    case "exact":
-      return escaped;
-    case "contains":
-      return `%${escaped}%`;
-    case void 0:
-      return `${escaped}%`;
-  }
-}
-function buildIlikeExtractSql(shape, paramName) {
-  switch (shape.kind) {
-    case "scalar":
-      return `resource->>'${shape.field}' ILIKE :${paramName}`;
-    case "array-of-scalars":
-      return [
-        "EXISTS (SELECT 1 FROM",
-        `jsonb_array_elements_text(resource->'${shape.field}') AS s_elem(text_val)`,
-        `WHERE s_elem.text_val ILIKE :${paramName})`
-      ].join(" ");
-    case "array-of-objects":
-      return [
-        "EXISTS (SELECT 1 FROM",
-        `jsonb_array_elements(resource->'${shape.field}') AS s_obj(obj)`,
-        `WHERE s_obj.obj->>'${shape.subfield}' ILIKE :${paramName})`
-      ].join(" ");
-  }
-}
-function emitStringPredicate(opts) {
-  const shape = jsonbPathToStringShape(opts.jsonbPath);
-  const modifier = opts.modifier === void 0 ? void 0 : checkModifier(opts.modifier);
-  const sql = buildIlikeExtractSql(shape, opts.paramName);
-  const pattern = buildLikePattern(opts.rawValue, modifier);
-  const params = [
-    { name: opts.paramName, value: pattern }
-  ];
-  return { sql, params };
-}
-function checkModifier(modifier) {
-  if (!isStringModifier(modifier)) {
-    throw new Error(
-      `String predicate does not support modifier ":${modifier}". Supported: ${STRING_MODIFIERS.map((m) => `:${m}`).join(", ")}.`
-    );
-  }
-  return modifier;
-}
-
-// src/data/search/engine/token-predicate.ts
-function jsonbPathToTokenShape(jsonbPath) {
-  const scalar = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
-  if (scalar) {
-    return { kind: "scalar", field: scalar[1] };
-  }
-  const arrayOfScalars = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]$/.exec(jsonbPath);
-  if (arrayOfScalars) {
-    return { kind: "array-of-scalars", field: arrayOfScalars[1] };
-  }
-  const arrayOfObjs = /^\$\.([A-Za-z_][A-Za-z0-9_]*)\[\*\]\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
-    jsonbPath
-  );
-  if (arrayOfObjs) {
-    return {
-      kind: "array-of-objects",
-      field: arrayOfObjs[1],
-      subfield: arrayOfObjs[2]
-    };
-  }
-  throw new Error(
-    `Token predicate cannot translate JSONPath "${jsonbPath}". Supported shapes: "$.field", "$.field[*]", "$.field[*].subfield".`
-  );
-}
-function parseTokenValue(raw) {
-  const idx = raw.indexOf("|");
-  if (idx === -1) {
-    return { code: raw };
-  }
-  const system = raw.slice(0, idx);
-  const code = raw.slice(idx + 1);
-  return system.length > 0 ? { system, code } : { code };
-}
-function wrapTokenInShape(shape, value) {
-  switch (shape.kind) {
-    case "scalar":
-      return { [shape.field]: value };
-    case "array-of-scalars":
-      return { [shape.field]: [value] };
-    case "array-of-objects":
-      return { [shape.field]: [{ [shape.subfield]: value }] };
-  }
-}
-function emitTokenPredicate(opts) {
-  const shape = jsonbPathToTokenShape(opts.jsonbPath);
-  const { code } = parseTokenValue(opts.rawValue);
-  const payload = wrapTokenInShape(shape, code);
-  const sql = `resource @> :${opts.paramName}::jsonb`;
-  const params = [
-    { name: opts.paramName, value: JSON.stringify(payload) }
-  ];
-  return { sql, params };
-}
-
-// src/data/search/engine/combinator.ts
-function parseQueryKey(key) {
-  const idx = key.indexOf(":");
-  if (idx === -1) {
-    return { code: key, modifier: void 0 };
-  }
-  return { code: key.slice(0, idx), modifier: key.slice(idx + 1) };
-}
-function flattenQueryValues(raw) {
-  const list = Array.isArray(raw) ? raw : [raw];
-  const out = [];
-  for (const v of list) {
-    for (const piece of v.split(",")) {
-      out.push(piece);
-    }
-  }
-  return out;
-}
-function parseQueryEntries(query) {
-  const entries = [];
-  for (const [rawKey, rawValue] of Object.entries(query)) {
-    if (rawValue === void 0) continue;
-    const { code, modifier } = parseQueryKey(rawKey);
-    entries.push({
-      code,
-      modifier,
-      values: flattenQueryValues(rawValue)
-    });
-  }
-  return entries;
-}
-function findParam(params, code) {
-  return params.find((p) => p.code === code);
-}
-function checkModifierAllowed(modifier, param) {
-  const universal = modifier === "missing" || modifier === "not";
-  const stringNative = param.type === "string" && (modifier === "exact" || modifier === "contains");
-  if (universal || stringNative) {
-    if (param.modifiers && !param.modifiers.includes(modifier)) {
-      throw new Error(
-        `Modifier ":${modifier}" is not in the allow-list for param "${param.code}".`
-      );
-    }
-    return;
-  }
-  throw new Error(
-    `Modifier ":${modifier}" is not recognized for param "${param.code}" (type "${param.type}").`
-  );
-}
-function emitOne(opts) {
-  const { param, modifier, rawValue, paramName, context } = opts;
-  if (modifier === "missing") {
-    const missing = parseMissingValue(rawValue);
-    return emitFieldMissingPredicate({
-      jsonbPath: param.jsonbPath,
-      missing
-    });
-  }
-  const negate = modifier === "not";
-  const effectiveModifier = negate ? void 0 : modifier;
-  const inner = emitForType({
-    paramType: param.type,
-    jsonbPath: param.jsonbPath,
-    rawValue,
-    paramName,
-    modifier: effectiveModifier,
-    context
-  });
-  if (!negate) {
-    return inner;
-  }
-  return { sql: `NOT (${inner.sql})`, params: inner.params };
-}
-function parseMissingValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  throw new Error(
-    `:missing requires a value of "true" or "false"; received "${raw}".`
-  );
-}
-function emitForType(opts) {
-  switch (opts.paramType) {
-    case "token":
-      return emitTokenPredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "date":
-      return emitDatePredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "reference":
-      return emitReferencePredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        context: opts.context
-      });
-    case "string":
-      return emitStringPredicate({
-        jsonbPath: opts.jsonbPath,
-        rawValue: opts.rawValue,
-        paramName: opts.paramName,
-        modifier: opts.modifier,
-        context: opts.context
-      });
-  }
-}
-function combineSearchPredicates(opts) {
-  const entries = parseQueryEntries(opts.query);
-  const groupSqls = [];
-  const allParams = [];
-  let paramIdx = 0;
-  for (const entry of entries) {
-    const registered = findParam(opts.registeredParams, entry.code);
-    if (!registered) {
-      continue;
-    }
-    if (entry.modifier !== void 0) {
-      checkModifierAllowed(entry.modifier, registered);
-    }
-    if (entry.values.length === 0) {
-      continue;
-    }
-    const fragmentSqls = [];
-    let valueIdx = 0;
-    for (const rawValue of entry.values) {
-      const paramName = `p${paramIdx}v${valueIdx}`;
-      const frag = emitOne({
-        param: registered,
-        modifier: entry.modifier,
-        rawValue,
-        paramName,
-        context: opts.context
-      });
-      fragmentSqls.push(frag.sql);
-      for (const p of frag.params) {
-        allParams.push(p);
-      }
-      valueIdx++;
-    }
-    paramIdx++;
-    if (fragmentSqls.length === 1) {
-      groupSqls.push(fragmentSqls[0]);
-    } else {
-      groupSqls.push(`(${fragmentSqls.join(" OR ")})`);
+    basePath: BASE_PATH.ORGANIZATIONAFFILIATION,
+    listOperation: listOrganizationAffiliationsOperation,
+    errorLogContext: "GET /OrganizationAffiliation list error:"
+  });
+}
+
+// src/data/operations/data/organizationaffiliation/organizationaffiliation-update-operation.ts
+async function updateOrganizationAffiliationOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.organizationaffiliation,
+    tenantId,
+    workspaceId,
+    id,
+    "OrganizationAffiliation",
+    context,
+    (existingResourceStr) => buildUpdatedResourceWithAudit(
+      body,
+      id,
+      date,
+      actorId,
+      actorName,
+      existingResourceStr,
+      "OrganizationAffiliation"
+    )
+  );
+}
+
+// src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation-update-route.ts
+async function updateOrganizationAffiliationRoute(req, res) {
+  const bodyResult = requireJsonBodyAs(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const resource = {
+    ...body,
+    resourceType: "OrganizationAffiliation",
+    id
+  };
+  try {
+    const result = await updateOrganizationAffiliationOperation({
+      context: ctx,
+      id,
+      body: resource
+    });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `OrganizationAffiliation ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
     }
+    return sendOperationOutcome500(
+      res,
+      err,
+      "PUT OrganizationAffiliation error:"
+    );
   }
-  if (groupSqls.length === 0) {
-    return { sql: "", params: [] };
+}
+
+// src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation.ts
+var router107 = express107.Router();
+router107.get("/", listOrganizationAffiliationsRoute);
+router107.get("/:id", getOrganizationAffiliationByIdRoute);
+router107.post("/", createOrganizationAffiliationRoute);
+router107.put("/:id", updateOrganizationAffiliationRoute);
+router107.delete("/:id", deleteOrganizationAffiliationRoute);
+
+// src/data/rest-api/routes/data/patient/patient.ts
+import express108 from "express";
+
+// src/data/rest-api/routes/data/patient/patient-create-route.ts
+async function createPatientRoute(req, res) {
+  const bodyResult = requireJsonBodyAs(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const patient = {
+    ...body,
+    resourceType: "Patient"
+  };
+  try {
+    const result = await createPatientOperation({
+      context: ctx,
+      body: patient
+    });
+    return res.status(201).location(`${BASE_PATH.PATIENT}/${result.id}`).json(result.resource);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "POST Patient error:");
   }
-  return { sql: groupSqls.join(" AND "), params: allParams };
 }
 
-// src/data/search/operations/generic-search-operation.ts
-var DEFAULT_LIMIT7 = 100;
-function buildGenericSearchSql(opts) {
-  const lines = [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = :resourceType",
-    "  AND deleted_at IS NULL"
-  ];
-  if (opts.combinedSql.length > 0) {
-    lines.push(`  AND (${opts.combinedSql})`);
+// src/data/operations/data/patient/patient-delete-operation.ts
+async function deletePatientOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/patient/patient-delete-route.ts
+async function deletePatientRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    await deletePatientOperation({ context: ctx, id });
+    return res.status(204).send();
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "DELETE Patient error:");
   }
-  lines.push("ORDER BY last_updated DESC");
-  lines.push("LIMIT :limit;");
-  return lines.join("\n");
 }
-async function genericSearchOperation(params) {
-  const { resourceType, tenantId, workspaceId, query, resolver } = params;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT7;
-  const registeredParams = resolver(resourceType, tenantId);
-  const context = { tenantId, workspaceId, resourceType };
-  const combined = combineSearchPredicates({
-    query,
-    registeredParams,
-    context
-  });
-  const sql = buildGenericSearchSql({ combinedSql: combined.sql });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "resourceType", value: resourceType },
-    { name: "limit", value: limit },
-    ...combined.params
-  ];
-  const rows = await runner.query(sql, queryParams);
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: { ...row.resource, id: row.id }
-  }));
-  return { entries, total: entries.length };
+
+// src/data/operations/data/patient/patient-get-by-id-operation.ts
+async function getPatientByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    id,
+    "Patient"
+  );
 }
 
-// src/data/search/registry/patient-search-parameters.ts
-var PATIENT_SEARCH_PARAMETERS = [
-  { code: "gender", type: "token", jsonbPath: "$.gender" },
-  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
-  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
-  {
-    code: "name",
-    type: "string",
-    jsonbPath: "$.name[*].text",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "family",
-    type: "string",
-    jsonbPath: "$.name[*].family",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "given",
-    type: "string",
-    jsonbPath: "$.name[*].given",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  { code: "active", type: "token", jsonbPath: "$.active" },
-  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
-  {
-    code: "general-practitioner",
-    type: "reference",
-    jsonbPath: "$.generalPractitioner[*]"
-  },
-  {
-    code: "organization",
-    type: "reference",
-    jsonbPath: "$.managingOrganization"
+// src/data/rest-api/routes/data/patient/patient-get-by-id-route.ts
+async function getPatientByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    const result = await getPatientByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Patient ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Patient error:");
   }
-];
+}
 
-// src/data/search/registry/resolver.ts
-var STATIC_SEARCH_PARAMETER_MAP = {
-  Patient: PATIENT_SEARCH_PARAMETERS
-};
-var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
-function getRegisteredSearchParameters(resourceType) {
-  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+// src/data/operations/data/patient/patient-list-operation.ts
+async function listPatientsOperation(params) {
+  const { context, tableName, mode } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.patient,
+    tenantId,
+    workspaceId,
+    mode
+  );
 }
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier(key) {
+function stripModifier2(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter(key) {
+function isResultParameter2(key) {
   return key.startsWith("_");
 }
 function sendInvalidSearch4003(res, diagnostics) {
@@ -25974,17 +25730,17 @@ function sendInvalidSearch4003(res, diagnostics) {
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys(query) {
+function extractSearchParamKeys2(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter(rawKey)) {
+    if (isResultParameter2(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier(rawKey) });
+    out.push({ rawKey, code: stripModifier2(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics(unknownCodes) {
+function buildUnknownParamDiagnostics2(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -25993,7 +25749,7 @@ function buildUnknownParamDiagnostics(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference(query, searchParamKeys) {
+function findMalformedReference2(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -26016,7 +25772,7 @@ function findMalformedReference(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys(
+  const searchParamKeys = extractSearchParamKeys2(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -26034,10 +25790,10 @@ async function listPatientsRoute(req, res) {
   if (unknownCodes.length > 0) {
     return sendInvalidSearch4003(
       res,
-      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics2([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference(
+  const malformedRef = findMalformedReference2(
     req.query,
     searchParamKeys
   );
@@ -29845,7 +29601,7 @@ async function listSchedulesOperation(params) {
 }
 
 // src/data/operations/data/schedule/schedule-search-by-actor-operation.ts
-var DEFAULT_LIMIT8 = 100;
+var DEFAULT_LIMIT5 = 100;
 function buildSearchSchedulesByActorSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -29863,7 +29619,7 @@ async function searchSchedulesByActorOperation(params) {
   const { context, actorReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT8;
+  const limit = params.limit ?? DEFAULT_LIMIT5;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "array-of-references", field: "actor" },
     reference: actorReference,
@@ -29889,7 +29645,7 @@ async function searchSchedulesByActorOperation(params) {
 }
 
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
-function singleStringQueryParam3(req, name) {
+function singleStringQueryParam2(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -29904,7 +29660,7 @@ function sendInvalidSearch4004(res, diagnostics) {
   });
 }
 async function listSchedulesRoute(req, res) {
-  const actorRef = singleStringQueryParam3(req, "actor");
+  const actorRef = singleStringQueryParam2(req, "actor");
   if (actorRef !== void 0) {
     if (parseTypedReference(actorRef) === void 0) {
       return sendInvalidSearch4004(
@@ -33609,7 +33365,7 @@ async function listTasksOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-owner-operation.ts
-var DEFAULT_LIMIT9 = 100;
+var DEFAULT_LIMIT6 = 100;
 function buildSearchTasksByOwnerSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33627,7 +33383,7 @@ async function searchTasksByOwnerOperation(params) {
   const { context, ownerReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT9;
+  const limit = params.limit ?? DEFAULT_LIMIT6;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "owner" },
     reference: ownerReference,
@@ -33653,7 +33409,7 @@ async function searchTasksByOwnerOperation(params) {
 }
 
 // src/data/operations/data/task/task-search-by-requester-operation.ts
-var DEFAULT_LIMIT10 = 100;
+var DEFAULT_LIMIT7 = 100;
 function buildSearchTasksByRequesterSql() {
   return [
     "SELECT resource_id AS id, resource",
@@ -33671,7 +33427,7 @@ async function searchTasksByRequesterOperation(params) {
   const { context, requesterReference } = params;
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT10;
+  const limit = params.limit ?? DEFAULT_LIMIT7;
   const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
     shape: { kind: "scalar", field: "requester" },
     reference: requesterReference,
@@ -33697,7 +33453,7 @@ async function searchTasksByRequesterOperation(params) {
 }
 
 // src/data/rest-api/routes/data/task/task-list-route.ts
-function singleStringQueryParam4(req, name) {
+function singleStringQueryParam3(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -33712,8 +33468,8 @@ function sendInvalidSearch4005(res, diagnostics) {
   });
 }
 async function listTasksRoute(req, res) {
-  const ownerRef = singleStringQueryParam4(req, "owner");
-  const requesterRef = singleStringQueryParam4(req, "requester");
+  const ownerRef = singleStringQueryParam3(req, "owner");
+  const requesterRef = singleStringQueryParam3(req, "requester");
   if (ownerRef !== void 0 && requesterRef !== void 0) {
     return sendInvalidSearch4005(
       res,