@openhi/constructs 0.0.100 → 0.0.101

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

@@ -4886,55 +4886,6 @@ function getDefaultPostgresQueryRunner() {
   return cached;
 }
 
-// src/data/operations/data/appointment/appointment-search-by-date-operation.ts
-var DEFAULT_LIMIT = 100;
-function buildSearchAppointmentsByDateSql(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"
-  ];
-  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 searchAppointmentsByDateOperation(params) {
-  const { context, dateConstraints } = params;
-  if (dateConstraints.length === 0) {
-    throw new Error(
-      "searchAppointmentsByDateOperation requires at least one dateConstraint"
-    );
-  }
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT;
-  const sql = buildSearchAppointmentsByDateSql({ dateConstraints });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { 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/operations/data/encounter/encounter-period-search-predicate.ts
 var PERIOD_SEARCH_PREFIXES = [
   "gt",
@@ -4987,7 +4938,7 @@ function buildPeriodSearchPredicateParams(constraints) {
 }
 
 // src/data/operations/data/encounter/encounter-search-by-patient-operation.ts
-var DEFAULT_LIMIT2 = 100;
+var DEFAULT_LIMIT = 100;
 function buildOpenHiResourceUrn(opts) {
   return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
 }
@@ -5017,7 +4968,7 @@ async function searchEncountersByPatientOperation(params) {
   const periodConstraints = params.periodConstraints ?? [];
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT2;
+  const limit = params.limit ?? DEFAULT_LIMIT;
   const containmentRelative = JSON.stringify({
     subject: { reference: `Patient/${patientId}` }
   });
@@ -5051,8 +5002,155 @@ async function searchEncountersByPatientOperation(params) {
   return { entries, total: entries.length };
 }
 
-// src/data/operations/data/appointment/appointment-search-by-patient-operation.ts
+// src/data/operations/data/reference-containment-predicate.ts
+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))
+  };
+}
+
+// src/data/operations/data/appointment/appointment-search-by-actor-operation.ts
+var DEFAULT_LIMIT2 = 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}`);
+  }
+  lines.push("ORDER BY last_updated DESC");
+  lines.push("LIMIT :limit;");
+  return lines.join("\n");
+}
+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_LIMIT2;
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape: {
+      kind: "array-of-objects",
+      field: "participant",
+      subfield: "actor"
+    },
+    reference: actorReference,
+    tenantId,
+    workspaceId
+  });
+  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
+    }
+  }));
+  return { entries, total: entries.length };
+}
+
+// src/data/operations/data/appointment/appointment-search-by-date-operation.ts
 var DEFAULT_LIMIT3 = 100;
+function buildSearchAppointmentsByDateSql(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"
+  ];
+  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 searchAppointmentsByDateOperation(params) {
+  const { context, dateConstraints } = params;
+  if (dateConstraints.length === 0) {
+    throw new Error(
+      "searchAppointmentsByDateOperation requires at least one dateConstraint"
+    );
+  }
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT3;
+  const sql = buildSearchAppointmentsByDateSql({ dateConstraints });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { 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/operations/data/appointment/appointment-search-by-patient-operation.ts
+var DEFAULT_LIMIT4 = 100;
 function buildSearchAppointmentsByPatientSql(opts) {
   const datePredicates = buildAppointmentDateSearchPredicateSql(
     opts?.dateConstraints ?? []
@@ -5079,7 +5177,7 @@ async function searchAppointmentsByPatientOperation(params) {
   const dateConstraints = params.dateConstraints ?? [];
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT3;
+  const limit = params.limit ?? DEFAULT_LIMIT4;
   const containmentRelative = JSON.stringify({
     participant: [{ actor: { reference: `Patient/${patientId}` } }]
   });
@@ -5166,11 +5264,45 @@ function sendInvalidSearch400(res, diagnostics) {
 }
 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 dateConstraints = parsed;
+  if (patientId !== void 0 && actorRef !== void 0) {
+    return sendInvalidSearch400(
+      res,
+      "?patient= and ?actor= cannot be combined on the same request."
+    );
+  }
+  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 {
@@ -12762,7 +12894,7 @@ async function listEncountersOperation(params) {
 }
 
 // src/data/operations/data/encounter/encounter-search-by-date-operation.ts
-var DEFAULT_LIMIT4 = 100;
+var DEFAULT_LIMIT5 = 100;
 function buildSearchEncountersByDateSql(opts) {
   const periodPredicates = buildPeriodSearchPredicateSql(
     opts.periodConstraints
@@ -12791,7 +12923,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_LIMIT5;
   const sql = buildSearchEncountersByDateSql({ periodConstraints });
   const queryParams = [
     { name: "tenantId", value: tenantId },
@@ -12810,6 +12942,64 @@ async function searchEncountersByDateOperation(params) {
   return { entries, total: entries.length };
 }
 
+// src/data/operations/data/encounter/encounter-search-by-participant-operation.ts
+var DEFAULT_LIMIT6 = 100;
+function buildSearchEncountersByParticipantSql(opts) {
+  const periodPredicates = buildPeriodSearchPredicateSql(
+    opts?.periodConstraints ?? []
+  );
+  const lines = [
+    "SELECT resource_id AS id, resource",
+    "FROM resources",
+    "WHERE tenant_id = :tenantId",
+    "  AND workspace_id = :workspaceId",
+    "  AND resource_type = 'Encounter'",
+    "  AND deleted_at IS NULL",
+    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`
+  ];
+  for (const fragment of periodPredicates) {
+    lines.push(`  AND ${fragment}`);
+  }
+  lines.push("ORDER BY last_updated DESC");
+  lines.push("LIMIT :limit;");
+  return lines.join("\n");
+}
+async function searchEncountersByParticipantOperation(params) {
+  const { context, participantReference } = params;
+  const periodConstraints = params.periodConstraints ?? [];
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT6;
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape: {
+      kind: "array-of-objects",
+      field: "participant",
+      subfield: "individual"
+    },
+    reference: participantReference,
+    tenantId,
+    workspaceId
+  });
+  const sql = buildSearchEncountersByParticipantSql({ periodConstraints });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "containmentRelative", value: containmentRelative },
+    { name: "containmentUrn", value: containmentUrn },
+    { name: "limit", value: limit },
+    ...buildPeriodSearchPredicateParams(periodConstraints)
+  ];
+  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/rest-api/routes/data/encounter/encounter-list-route.ts
 function singleStringQueryParam2(req, name) {
   const v = req.query[name];
@@ -12859,11 +13049,42 @@ function sendInvalidSearch4002(res, diagnostics) {
 }
 async function listEncountersRoute(req, res) {
   const patientId = singleStringQueryParam2(req, "patient");
+  const participantRef = singleStringQueryParam2(req, "participant");
   const parsed = parseEncounterDateConstraints(req);
   if (isError2(parsed)) {
     return sendInvalidSearch4002(res, parsed.error);
   }
   const periodConstraints = parsed;
+  if (patientId !== void 0 && participantRef !== void 0) {
+    return sendInvalidSearch4002(
+      res,
+      "?patient= and ?participant= cannot be combined on the same request."
+    );
+  }
+  if (participantRef !== void 0) {
+    if (parseTypedReference(participantRef) === void 0) {
+      return sendInvalidSearch4002(
+        res,
+        `?participant must be a typed reference like "Practitioner/<id>"; got "${participantRef}".`
+      );
+    }
+    const ctx = req.openhiContext;
+    try {
+      const result = await searchEncountersByParticipantOperation({
+        context: ctx,
+        participantReference: participantRef,
+        periodConstraints
+      });
+      const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
+      return res.json(bundle);
+    } catch (err) {
+      return sendOperationOutcome500(
+        res,
+        err,
+        "GET /Encounter?participant= search error:"
+      );
+    }
+  }
   if (patientId !== void 0) {
     const ctx = req.openhiContext;
     try {
@@ -24664,8 +24885,91 @@ async function listPatientsOperation(params) {
   );
 }
 
+// src/data/operations/data/patient/patient-search-by-general-practitioner-operation.ts
+var DEFAULT_LIMIT7 = 100;
+function buildSearchPatientsByGeneralPractitionerSql() {
+  return [
+    "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");
+}
+async function searchPatientsByGeneralPractitionerOperation(params) {
+  const { context, generalPractitionerReference } = params;
+  const { tenantId, workspaceId } = context;
+  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 sql = buildSearchPatientsByGeneralPractitionerSql();
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "containmentRelative", value: containmentRelative },
+    { name: "containmentUrn", value: containmentUrn },
+    { name: "limit", value: limit }
+  ];
+  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/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;
+  }
+  const trimmed = v.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function sendInvalidSearch4003(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
 async function listPatientsRoute(req, res) {
+  const generalPractitionerRef = singleStringQueryParam3(
+    req,
+    "general-practitioner"
+  );
+  if (generalPractitionerRef !== void 0) {
+    if (parseTypedReference(generalPractitionerRef) === void 0) {
+      return sendInvalidSearch4003(
+        res,
+        `?general-practitioner must be a typed reference like "Practitioner/<id>"; got "${generalPractitionerRef}".`
+      );
+    }
+    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:"
+      );
+    }
+  }
   return handleListRoute({
     req,
     res,
@@ -28552,8 +28856,90 @@ async function listSchedulesOperation(params) {
   );
 }
 
+// src/data/operations/data/schedule/schedule-search-by-actor-operation.ts
+var DEFAULT_LIMIT8 = 100;
+function buildSearchSchedulesByActorSql() {
+  return [
+    "SELECT resource_id AS id, resource",
+    "FROM resources",
+    "WHERE tenant_id = :tenantId",
+    "  AND workspace_id = :workspaceId",
+    "  AND resource_type = 'Schedule'",
+    "  AND deleted_at IS NULL",
+    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
+    "ORDER BY last_updated DESC",
+    "LIMIT :limit;"
+  ].join("\n");
+}
+async function searchSchedulesByActorOperation(params) {
+  const { context, actorReference } = params;
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT8;
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape: { kind: "array-of-references", field: "actor" },
+    reference: actorReference,
+    tenantId,
+    workspaceId
+  });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "containmentRelative", value: containmentRelative },
+    { name: "containmentUrn", value: containmentUrn },
+    { name: "limit", value: limit }
+  ];
+  const rows = await runner.query(
+    buildSearchSchedulesByActorSql(),
+    queryParams
+  );
+  const entries = rows.map((row) => ({
+    id: row.id,
+    resource: { ...row.resource, id: row.id }
+  }));
+  return { entries, total: entries.length };
+}
+
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
+function singleStringQueryParam4(req, name) {
+  const v = req.query[name];
+  if (typeof v !== "string") {
+    return void 0;
+  }
+  const trimmed = v.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function sendInvalidSearch4004(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
 async function listSchedulesRoute(req, res) {
+  const actorRef = singleStringQueryParam4(req, "actor");
+  if (actorRef !== void 0) {
+    if (parseTypedReference(actorRef) === void 0) {
+      return sendInvalidSearch4004(
+        res,
+        `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
+      );
+    }
+    const ctx = req.openhiContext;
+    try {
+      const result = await searchSchedulesByActorOperation({
+        context: ctx,
+        actorReference: actorRef
+      });
+      const bundle = buildSearchsetBundle(BASE_PATH.SCHEDULE, result.entries);
+      return res.json(bundle);
+    } catch (err) {
+      return sendOperationOutcome500(
+        res,
+        err,
+        "GET /Schedule?actor= search error:"
+      );
+    }
+  }
   return handleListRoute({
     req,
     res,
@@ -32234,8 +32620,164 @@ async function listTasksOperation(params) {
   );
 }
 
+// src/data/operations/data/task/task-search-by-owner-operation.ts
+var DEFAULT_LIMIT9 = 100;
+function buildSearchTasksByOwnerSql() {
+  return [
+    "SELECT resource_id AS id, resource",
+    "FROM resources",
+    "WHERE tenant_id = :tenantId",
+    "  AND workspace_id = :workspaceId",
+    "  AND resource_type = 'Task'",
+    "  AND deleted_at IS NULL",
+    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
+    "ORDER BY last_updated DESC",
+    "LIMIT :limit;"
+  ].join("\n");
+}
+async function searchTasksByOwnerOperation(params) {
+  const { context, ownerReference } = params;
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT9;
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape: { kind: "scalar", field: "owner" },
+    reference: ownerReference,
+    tenantId,
+    workspaceId
+  });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "containmentRelative", value: containmentRelative },
+    { name: "containmentUrn", value: containmentUrn },
+    { name: "limit", value: limit }
+  ];
+  const rows = await runner.query(
+    buildSearchTasksByOwnerSql(),
+    queryParams
+  );
+  const entries = rows.map((row) => ({
+    id: row.id,
+    resource: { ...row.resource, id: row.id }
+  }));
+  return { entries, total: entries.length };
+}
+
+// src/data/operations/data/task/task-search-by-requester-operation.ts
+var DEFAULT_LIMIT10 = 100;
+function buildSearchTasksByRequesterSql() {
+  return [
+    "SELECT resource_id AS id, resource",
+    "FROM resources",
+    "WHERE tenant_id = :tenantId",
+    "  AND workspace_id = :workspaceId",
+    "  AND resource_type = 'Task'",
+    "  AND deleted_at IS NULL",
+    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
+    "ORDER BY last_updated DESC",
+    "LIMIT :limit;"
+  ].join("\n");
+}
+async function searchTasksByRequesterOperation(params) {
+  const { context, requesterReference } = params;
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT10;
+  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
+    shape: { kind: "scalar", field: "requester" },
+    reference: requesterReference,
+    tenantId,
+    workspaceId
+  });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "containmentRelative", value: containmentRelative },
+    { name: "containmentUrn", value: containmentUrn },
+    { name: "limit", value: limit }
+  ];
+  const rows = await runner.query(
+    buildSearchTasksByRequesterSql(),
+    queryParams
+  );
+  const entries = rows.map((row) => ({
+    id: row.id,
+    resource: { ...row.resource, id: row.id }
+  }));
+  return { entries, total: entries.length };
+}
+
 // src/data/rest-api/routes/data/task/task-list-route.ts
+function singleStringQueryParam5(req, name) {
+  const v = req.query[name];
+  if (typeof v !== "string") {
+    return void 0;
+  }
+  const trimmed = v.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function sendInvalidSearch4005(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
 async function listTasksRoute(req, res) {
+  const ownerRef = singleStringQueryParam5(req, "owner");
+  const requesterRef = singleStringQueryParam5(req, "requester");
+  if (ownerRef !== void 0 && requesterRef !== void 0) {
+    return sendInvalidSearch4005(
+      res,
+      "?owner= and ?requester= cannot be combined on the same request."
+    );
+  }
+  if (ownerRef !== void 0) {
+    if (parseTypedReference(ownerRef) === void 0) {
+      return sendInvalidSearch4005(
+        res,
+        `?owner must be a typed reference like "Practitioner/<id>"; got "${ownerRef}".`
+      );
+    }
+    const ctx = req.openhiContext;
+    try {
+      const result = await searchTasksByOwnerOperation({
+        context: ctx,
+        ownerReference: ownerRef
+      });
+      const bundle = buildSearchsetBundle(BASE_PATH.TASK, result.entries);
+      return res.json(bundle);
+    } catch (err) {
+      return sendOperationOutcome500(
+        res,
+        err,
+        "GET /Task?owner= search error:"
+      );
+    }
+  }
+  if (requesterRef !== void 0) {
+    if (parseTypedReference(requesterRef) === void 0) {
+      return sendInvalidSearch4005(
+        res,
+        `?requester must be a typed reference like "Practitioner/<id>"; got "${requesterRef}".`
+      );
+    }
+    const ctx = req.openhiContext;
+    try {
+      const result = await searchTasksByRequesterOperation({
+        context: ctx,
+        requesterReference: requesterRef
+      });
+      const bundle = buildSearchsetBundle(BASE_PATH.TASK, result.entries);
+      return res.json(bundle);
+    } catch (err) {
+      return sendOperationOutcome500(
+        res,
+        err,
+        "GET /Task?requester= search error:"
+      );
+    }
+  }
   return handleListRoute({
     req,
     res,