@openhi/constructs 0.0.135 → 0.0.136

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

@@ -2495,7 +2495,6 @@ var ENV_VAR_NAMES = [
   "OPENHI_RUNTIME_CONFIG_COGNITO_USER_POOL_ID",
   "OPENHI_RUNTIME_CONFIG_COGNITO_USER_POOL_CLIENT_ID",
   "OPENHI_RUNTIME_CONFIG_COGNITO_DOMAIN_URL",
-  "OPENHI_RUNTIME_CONFIG_COGNITO_REDIRECT_URI",
   "OPENHI_RUNTIME_CONFIG_API_BASE_URL"
 ];
 var CACHE_CONTROL_HEADER = "public, max-age=300, s-maxage=300";
@@ -2512,7 +2511,6 @@ function runtimeConfigGetRoute(_req, res) {
     cognitoUserPoolId: process.env.OPENHI_RUNTIME_CONFIG_COGNITO_USER_POOL_ID,
     cognitoUserPoolClientId: process.env.OPENHI_RUNTIME_CONFIG_COGNITO_USER_POOL_CLIENT_ID,
     cognitoDomainUrl: process.env.OPENHI_RUNTIME_CONFIG_COGNITO_DOMAIN_URL,
-    cognitoRedirectUri: process.env.OPENHI_RUNTIME_CONFIG_COGNITO_REDIRECT_URI,
     apiBaseUrl: process.env.OPENHI_RUNTIME_CONFIG_API_BASE_URL
   };
   res.setHeader("Cache-Control", CACHE_CONTROL_HEADER);
@@ -5532,6 +5530,29 @@ function getDefaultPostgresQueryRunner() {
 }
 
 // src/data/search/engine/date-predicate.ts
+var DATE_SEARCH_PREFIXES = [
+  "eq",
+  "gt",
+  "lt",
+  "ge",
+  "le",
+  "sa",
+  "eb"
+];
+function isDateSearchPrefix(s) {
+  return DATE_SEARCH_PREFIXES.includes(s);
+}
+var GENERIC_DATE_PREFIXES = ["eq", "gt", "ge", "lt", "le"];
+function isGenericDatePrefix(s) {
+  return GENERIC_DATE_PREFIXES.includes(s);
+}
+function parseDateSearchValue(raw) {
+  const head = raw.slice(0, 2);
+  if (isDateSearchPrefix(head) && raw.length > 2) {
+    return { prefix: head, value: raw.slice(2) };
+  }
+  return { prefix: "eq", value: raw };
+}
 function flatJsonbExtract(jsonbPath) {
   const match = /^\$\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(jsonbPath);
   if (!match) {
@@ -5541,6 +5562,40 @@ function flatJsonbExtract(jsonbPath) {
   }
   return `resource->>'${match[1]}'`;
 }
+function emitDatePredicate(opts) {
+  const { jsonbPath, rawValue, paramName } = opts;
+  const extract = flatJsonbExtract(jsonbPath);
+  const { prefix, value } = parseDateSearchValue(rawValue);
+  if (!isGenericDatePrefix(prefix)) {
+    throw new Error(
+      `Generic date predicate does not support prefix "${prefix}". Supported: ${GENERIC_DATE_PREFIXES.join(", ")}.`
+    );
+  }
+  const sql = buildSingleBoundSql(extract, prefix, paramName);
+  const params = [
+    { name: paramName, value }
+  ];
+  return { sql, params };
+}
+function buildSingleBoundSql(extract, prefix, paramName) {
+  switch (prefix) {
+    case "eq":
+      return `${extract} = :${paramName}`;
+    case "gt":
+      return `${extract} > :${paramName}`;
+    case "ge":
+      return `${extract} >= :${paramName}`;
+    case "lt":
+      return `${extract} < :${paramName}`;
+    case "le":
+      return `${extract} <= :${paramName}`;
+  }
+}
+function emitFieldMissingPredicate(opts) {
+  const extract = flatJsonbExtract(opts.jsonbPath);
+  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}`;
@@ -5656,6 +5711,46 @@ function buildReferenceContainmentPayload(params) {
     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/operations/data/appointment/appointment-search-by-actor-operation.ts
 var DEFAULT_LIMIT = 100;
@@ -25481,39 +25576,334 @@ async function listPatientsOperation(params) {
   );
 }
 
-// src/data/operations/data/patient/patient-search-by-general-practitioner-operation.ts
+// 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 ")})`);
+    }
+  }
+  if (groupSqls.length === 0) {
+    return { sql: "", params: [] };
+  }
+  return { sql: groupSqls.join(" AND "), params: allParams };
+}
+
+// src/data/search/operations/generic-search-operation.ts
 var DEFAULT_LIMIT7 = 100;
-function buildSearchPatientsByGeneralPractitionerSql() {
-  return [
+function buildGenericSearchSql(opts) {
+  const lines = [
     "SELECT resource_id AS id, resource",
     "FROM resources",
     "WHERE tenant_id = :tenantId",
     "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Patient'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
-    "ORDER BY last_updated DESC",
-    "LIMIT :limit;"
-  ].join("\n");
+    "  AND resource_type = :resourceType",
+    "  AND deleted_at IS NULL"
+  ];
+  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 searchPatientsByGeneralPractitionerOperation(params) {
-  const { context, generalPractitionerReference } = params;
-  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_LIMIT7;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: { kind: "array-of-references", field: "generalPractitioner" },
-    reference: generalPractitionerReference,
-    tenantId,
-    workspaceId
+  const registeredParams = resolver(resourceType, tenantId);
+  const context = { tenantId, workspaceId, resourceType };
+  const combined = combineSearchPredicates({
+    query,
+    registeredParams,
+    context
   });
-  const sql = buildSearchPatientsByGeneralPractitionerSql();
+  const sql = buildGenericSearchSql({ combinedSql: combined.sql });
   const queryParams = [
     { name: "tenantId", value: tenantId },
     { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit }
+    { name: "resourceType", value: resourceType },
+    { name: "limit", value: limit },
+    ...combined.params
   ];
   const rows = await runner.query(sql, queryParams);
   const entries = rows.map((row) => ({
@@ -25523,14 +25913,60 @@ async function searchPatientsByGeneralPractitionerOperation(params) {
   return { entries, total: entries.length };
 }
 
-// src/data/rest-api/routes/data/patient/patient-list-route.ts
-function singleStringQueryParam3(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 = {
+  Patient: PATIENT_SEARCH_PARAMETERS
+};
+var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+function getRegisteredSearchParameters(resourceType) {
+  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+}
+
+// src/data/rest-api/routes/data/patient/patient-list-route.ts
+var PATIENT_RESOURCE_TYPE = "Patient";
+function stripModifier(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter(key) {
+  return key.startsWith("_");
 }
 function sendInvalidSearch4003(res, diagnostics) {
   return res.status(400).json({
@@ -25538,41 +25974,93 @@ function sendInvalidSearch4003(res, diagnostics) {
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-async function listPatientsRoute(req, res) {
-  const generalPractitionerRef = singleStringQueryParam3(
-    req,
-    "general-practitioner"
+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(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Patient: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
-  if (generalPractitionerRef !== void 0) {
-    if (parseTypedReference(generalPractitionerRef) === void 0) {
-      return sendInvalidSearch4003(
-        res,
-        `?general-practitioner must be a typed reference like "Practitioner/<id>"; got "${generalPractitionerRef}".`
-      );
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
     }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchPatientsByGeneralPractitionerOperation({
-        context: ctx,
-        generalPractitionerReference: generalPractitionerRef
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.PATIENT, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Patient?general-practitioner= search error:"
-      );
+    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 handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.PATIENT,
-    listOperation: listPatientsOperation,
-    errorLogContext: "GET /Patient list error:"
-  });
+  return void 0;
+}
+async function listPatientsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.PATIENT,
+      listOperation: listPatientsOperation,
+      errorLogContext: "GET /Patient list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(PATIENT_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 sendInvalidSearch4003(
+      res,
+      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4003(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: PATIENT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.PATIENT, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Patient search error:");
+  }
 }
 
 // src/data/operations/data/patient/patient-update-operation.ts
@@ -29401,7 +29889,7 @@ async function searchSchedulesByActorOperation(params) {
 }
 
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
-function singleStringQueryParam4(req, name) {
+function singleStringQueryParam3(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -29416,7 +29904,7 @@ function sendInvalidSearch4004(res, diagnostics) {
   });
 }
 async function listSchedulesRoute(req, res) {
-  const actorRef = singleStringQueryParam4(req, "actor");
+  const actorRef = singleStringQueryParam3(req, "actor");
   if (actorRef !== void 0) {
     if (parseTypedReference(actorRef) === void 0) {
       return sendInvalidSearch4004(
@@ -33209,7 +33697,7 @@ async function searchTasksByRequesterOperation(params) {
 }
 
 // src/data/rest-api/routes/data/task/task-list-route.ts
-function singleStringQueryParam5(req, name) {
+function singleStringQueryParam4(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -33224,8 +33712,8 @@ function sendInvalidSearch4005(res, diagnostics) {
   });
 }
 async function listTasksRoute(req, res) {
-  const ownerRef = singleStringQueryParam5(req, "owner");
-  const requesterRef = singleStringQueryParam5(req, "requester");
+  const ownerRef = singleStringQueryParam4(req, "owner");
+  const requesterRef = singleStringQueryParam4(req, "requester");
   if (ownerRef !== void 0 && requesterRef !== void 0) {
     return sendInvalidSearch4005(
       res,