@openhi/constructs 0.0.97 → 0.0.99

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

@@ -5563,6 +5563,59 @@ async function getAppointmentByIdRoute(req, res) {
   }
 }
 
+// src/data/operations/data/appointment/appointment-date-search-predicate.ts
+var APPOINTMENT_DATE_SEARCH_PREFIXES = [
+  "gt",
+  "lt",
+  "ge",
+  "le",
+  "sa",
+  "eb"
+];
+function isAppointmentDateSearchPrefix(s) {
+  return APPOINTMENT_DATE_SEARCH_PREFIXES.includes(
+    s
+  );
+}
+var APPT_START = "resource->>'start'";
+var APPT_END = "resource->>'end'";
+var HAS_ANY_BOUND_GUARD = `(${APPT_START} IS NOT NULL OR ${APPT_END} IS NOT NULL)`;
+function buildSinglePredicateSql(prefix, paramName) {
+  switch (prefix) {
+    case "gt":
+      return `(${APPT_END} IS NULL OR ${APPT_END} > :${paramName})`;
+    case "lt":
+      return `(${APPT_START} IS NULL OR ${APPT_START} < :${paramName})`;
+    case "ge":
+      return `(${APPT_END} IS NULL OR ${APPT_END} >= :${paramName})`;
+    case "le":
+      return `(${APPT_START} IS NULL OR ${APPT_START} <= :${paramName})`;
+    case "sa":
+      return `(${APPT_START} IS NOT NULL AND ${APPT_START} > :${paramName})`;
+    case "eb":
+      return `(${APPT_END} IS NOT NULL AND ${APPT_END} < :${paramName})`;
+  }
+}
+function appointmentDateConstraintParamName(index) {
+  return `apptDateConstraint${index}`;
+}
+function buildAppointmentDateSearchPredicateSql(constraints) {
+  if (constraints.length === 0) {
+    return [];
+  }
+  const fragments = constraints.map(
+    (c, i) => buildSinglePredicateSql(c.prefix, appointmentDateConstraintParamName(i))
+  );
+  fragments.push(HAS_ANY_BOUND_GUARD);
+  return fragments;
+}
+function buildAppointmentDateSearchPredicateParams(constraints) {
+  return constraints.map((c, i) => ({
+    name: appointmentDateConstraintParamName(i),
+    value: c.value
+  }));
+}
+
 // src/data/operations/data/appointment/appointment-list-operation.ts
 async function listAppointmentsOperation(params) {
   const { context, tableName, mode } = params;
@@ -5576,8 +5629,406 @@ async function listAppointmentsOperation(params) {
   );
 }
 
+// src/data/postgres/data-api-postgres-query-runner.ts
+var import_client_rds_data = require("@aws-sdk/client-rds-data");
+var DataApiPostgresQueryRunner = class {
+  constructor(options) {
+    this.client = options.client ?? new import_client_rds_data.RDSDataClient({});
+    this.clusterArn = options.clusterArn;
+    this.secretArn = options.secretArn;
+    this.database = options.database;
+    this.schema = options.schema;
+  }
+  async query(sql, params) {
+    const out = await this.client.send(
+      new import_client_rds_data.ExecuteStatementCommand({
+        resourceArn: this.clusterArn,
+        secretArn: this.secretArn,
+        database: this.database,
+        schema: this.schema,
+        sql,
+        parameters: params.map(toSqlParameter),
+        // Results as named columns so we can map them back to JS objects.
+        includeResultMetadata: true,
+        // Encode JSONB results as strings, then parse client-side. Without
+        // this, Data API returns JSON values inline as their underlying types
+        // and complex JSONB columns get clipped.
+        formatRecordsAs: "JSON"
+      })
+    );
+    if (!out.formattedRecords) {
+      return [];
+    }
+    return JSON.parse(out.formattedRecords);
+  }
+};
+function toSqlParameter(param) {
+  if (param.value === null) {
+    return { name: param.name, value: { isNull: true } };
+  }
+  const v = param.value;
+  let field;
+  if (typeof v === "string") {
+    field = { stringValue: v };
+  } else if (typeof v === "boolean") {
+    field = { booleanValue: v };
+  } else if (Number.isInteger(v)) {
+    field = { longValue: v };
+  } else {
+    field = { doubleValue: v };
+  }
+  return { name: param.name, value: field };
+}
+
+// src/data/postgres/default-postgres-query-runner.ts
+var cached;
+function readEnv(name) {
+  const v = process.env[name]?.trim();
+  if (!v) {
+    throw new Error(
+      `Missing required env var for default PostgresQueryRunner: ${name}`
+    );
+  }
+  return v;
+}
+function getDefaultPostgresQueryRunner() {
+  if (!cached) {
+    cached = new DataApiPostgresQueryRunner({
+      clusterArn: readEnv("OPENHI_PG_CLUSTER_ARN"),
+      secretArn: readEnv("OPENHI_PG_SECRET_ARN"),
+      database: readEnv("OPENHI_PG_DATABASE"),
+      schema: readEnv("OPENHI_PG_SCHEMA")
+    });
+  }
+  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",
+  "lt",
+  "ge",
+  "le",
+  "sa",
+  "eb"
+];
+function isPeriodSearchPrefix(s) {
+  return PERIOD_SEARCH_PREFIXES.includes(s);
+}
+var PERIOD_START = "resource->'period'->>'start'";
+var PERIOD_END = "resource->'period'->>'end'";
+var HAS_ANY_BOUND_GUARD2 = `(${PERIOD_START} IS NOT NULL OR ${PERIOD_END} IS NOT NULL)`;
+function buildSinglePredicateSql2(prefix, paramName) {
+  switch (prefix) {
+    case "gt":
+      return `(${PERIOD_END} IS NULL OR ${PERIOD_END} > :${paramName})`;
+    case "lt":
+      return `(${PERIOD_START} IS NULL OR ${PERIOD_START} < :${paramName})`;
+    case "ge":
+      return `(${PERIOD_END} IS NULL OR ${PERIOD_END} >= :${paramName})`;
+    case "le":
+      return `(${PERIOD_START} IS NULL OR ${PERIOD_START} <= :${paramName})`;
+    case "sa":
+      return `(${PERIOD_START} IS NOT NULL AND ${PERIOD_START} > :${paramName})`;
+    case "eb":
+      return `(${PERIOD_END} IS NOT NULL AND ${PERIOD_END} < :${paramName})`;
+  }
+}
+function periodConstraintParamName(index) {
+  return `periodConstraint${index}`;
+}
+function buildPeriodSearchPredicateSql(constraints) {
+  if (constraints.length === 0) {
+    return [];
+  }
+  const fragments = constraints.map(
+    (c, i) => buildSinglePredicateSql2(c.prefix, periodConstraintParamName(i))
+  );
+  fragments.push(HAS_ANY_BOUND_GUARD2);
+  return fragments;
+}
+function buildPeriodSearchPredicateParams(constraints) {
+  return constraints.map((c, i) => ({
+    name: periodConstraintParamName(i),
+    value: c.value
+  }));
+}
+
+// src/data/operations/data/encounter/encounter-search-by-patient-operation.ts
+var DEFAULT_LIMIT2 = 100;
+function buildOpenHiResourceUrn(opts) {
+  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
+}
+function buildSearchEncountersByPatientSql(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 (resource @> :containmentRelative::jsonb",
+    "    OR resource @> :containmentUrn::jsonb)"
+  ];
+  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 searchEncountersByPatientOperation(params) {
+  const { context, patientId } = params;
+  const periodConstraints = params.periodConstraints ?? [];
+  const { tenantId, workspaceId } = context;
+  const runner = params.runner ?? getDefaultPostgresQueryRunner();
+  const limit = params.limit ?? DEFAULT_LIMIT2;
+  const containmentRelative = JSON.stringify({
+    subject: { reference: `Patient/${patientId}` }
+  });
+  const containmentUrn = JSON.stringify({
+    subject: {
+      reference: buildOpenHiResourceUrn({
+        tenantId,
+        workspaceId,
+        resourceType: "Patient",
+        resourceId: patientId
+      })
+    }
+  });
+  const sql = buildSearchEncountersByPatientSql({ 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/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/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;
+  }
+  const trimmed = v.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function isError(v) {
+  return v.error !== void 0;
+}
+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 sendInvalidSearch400(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
 async function listAppointmentsRoute(req, res) {
+  const patientId = singleStringQueryParam(req, "patient");
+  const parsed = parseAppointmentDateConstraints(req);
+  if (isError(parsed)) {
+    return sendInvalidSearch400(res, parsed.error);
+  }
+  const dateConstraints = parsed;
+  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:"
+      );
+    }
+  }
+  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:"
+      );
+    }
+  }
   return handleListRoute({
     req,
     res,
@@ -13127,127 +13578,45 @@ async function listEncountersOperation(params) {
   );
 }
 
-// src/data/postgres/data-api-postgres-query-runner.ts
-var import_client_rds_data = require("@aws-sdk/client-rds-data");
-var DataApiPostgresQueryRunner = class {
-  constructor(options) {
-    this.client = options.client ?? new import_client_rds_data.RDSDataClient({});
-    this.clusterArn = options.clusterArn;
-    this.secretArn = options.secretArn;
-    this.database = options.database;
-    this.schema = options.schema;
-  }
-  async query(sql, params) {
-    const out = await this.client.send(
-      new import_client_rds_data.ExecuteStatementCommand({
-        resourceArn: this.clusterArn,
-        secretArn: this.secretArn,
-        database: this.database,
-        schema: this.schema,
-        sql,
-        parameters: params.map(toSqlParameter),
-        // Results as named columns so we can map them back to JS objects.
-        includeResultMetadata: true,
-        // Encode JSONB results as strings, then parse client-side. Without
-        // this, Data API returns JSON values inline as their underlying types
-        // and complex JSONB columns get clipped.
-        formatRecordsAs: "JSON"
-      })
-    );
-    if (!out.formattedRecords) {
-      return [];
-    }
-    return JSON.parse(out.formattedRecords);
-  }
-};
-function toSqlParameter(param) {
-  if (param.value === null) {
-    return { name: param.name, value: { isNull: true } };
-  }
-  const v = param.value;
-  let field;
-  if (typeof v === "string") {
-    field = { stringValue: v };
-  } else if (typeof v === "boolean") {
-    field = { booleanValue: v };
-  } else if (Number.isInteger(v)) {
-    field = { longValue: v };
-  } else {
-    field = { doubleValue: v };
-  }
-  return { name: param.name, value: field };
-}
-
-// src/data/postgres/default-postgres-query-runner.ts
-var cached;
-function readEnv(name) {
-  const v = process.env[name]?.trim();
-  if (!v) {
-    throw new Error(
-      `Missing required env var for default PostgresQueryRunner: ${name}`
-    );
-  }
-  return v;
-}
-function getDefaultPostgresQueryRunner() {
-  if (!cached) {
-    cached = new DataApiPostgresQueryRunner({
-      clusterArn: readEnv("OPENHI_PG_CLUSTER_ARN"),
-      secretArn: readEnv("OPENHI_PG_SECRET_ARN"),
-      database: readEnv("OPENHI_PG_DATABASE"),
-      schema: readEnv("OPENHI_PG_SCHEMA")
-    });
-  }
-  return cached;
-}
-
-// src/data/operations/data/encounter/encounter-search-by-patient-operation.ts
-var DEFAULT_LIMIT = 100;
-function buildOpenHiResourceUrn(opts) {
-  return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
-}
-function buildSearchEncountersByPatientSql() {
-  return [
+// src/data/operations/data/encounter/encounter-search-by-date-operation.ts
+var DEFAULT_LIMIT4 = 100;
+function buildSearchEncountersByDateSql(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 (resource @> :containmentRelative::jsonb",
-    "    OR resource @> :containmentUrn::jsonb)",
-    "ORDER BY last_updated DESC",
-    "LIMIT :limit;"
-  ].join("\n");
+    "  AND deleted_at IS NULL"
+  ];
+  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 searchEncountersByPatientOperation(params) {
-  const { context, patientId } = params;
+async function searchEncountersByDateOperation(params) {
+  const { context, periodConstraints } = params;
+  if (periodConstraints.length === 0) {
+    throw new Error(
+      "searchEncountersByDateOperation requires at least one periodConstraint"
+    );
+  }
   const { tenantId, workspaceId } = context;
   const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT;
-  const containmentRelative = JSON.stringify({
-    subject: { reference: `Patient/${patientId}` }
-  });
-  const containmentUrn = JSON.stringify({
-    subject: {
-      reference: buildOpenHiResourceUrn({
-        tenantId,
-        workspaceId,
-        resourceType: "Patient",
-        resourceId: patientId
-      })
-    }
-  });
-  const rows = await runner.query(
-    buildSearchEncountersByPatientSql(),
-    [
-      { name: "tenantId", value: tenantId },
-      { name: "workspaceId", value: workspaceId },
-      { name: "containmentRelative", value: containmentRelative },
-      { name: "containmentUrn", value: containmentUrn },
-      { name: "limit", value: limit }
-    ]
-  );
+  const limit = params.limit ?? DEFAULT_LIMIT4;
+  const sql = buildSearchEncountersByDateSql({ periodConstraints });
+  const queryParams = [
+    { name: "tenantId", value: tenantId },
+    { name: "workspaceId", value: workspaceId },
+    { name: "limit", value: limit },
+    ...buildPeriodSearchPredicateParams(periodConstraints)
+  ];
+  const rows = await runner.query(sql, queryParams);
   const entries = rows.map((row) => ({
     id: row.id,
     resource: {
@@ -13259,7 +13628,7 @@ async function searchEncountersByPatientOperation(params) {
 }
 
 // src/data/rest-api/routes/data/encounter/encounter-list-route.ts
-function singleStringQueryParam(req, name) {
+function singleStringQueryParam2(req, name) {
   const v = req.query[name];
   if (typeof v !== "string") {
     return void 0;
@@ -13267,14 +13636,58 @@ function singleStringQueryParam(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
+function isError2(v) {
+  return v.error !== void 0;
+}
+function parseEncounterDateConstraints(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 (!isPeriodSearchPrefix(prefix)) {
+      return {
+        error: `Unsupported ?date= prefix in "${trimmed}". Supported prefixes: ${PERIOD_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 sendInvalidSearch4002(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
 async function listEncountersRoute(req, res) {
-  const patientId = singleStringQueryParam(req, "patient");
-  if (patientId) {
+  const patientId = singleStringQueryParam2(req, "patient");
+  const parsed = parseEncounterDateConstraints(req);
+  if (isError2(parsed)) {
+    return sendInvalidSearch4002(res, parsed.error);
+  }
+  const periodConstraints = parsed;
+  if (patientId !== void 0) {
     const ctx = req.openhiContext;
     try {
       const result = await searchEncountersByPatientOperation({
         context: ctx,
-        patientId
+        patientId,
+        periodConstraints
       });
       const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
       return res.json(bundle);
@@ -13286,6 +13699,23 @@ async function listEncountersRoute(req, res) {
       );
     }
   }
+  if (periodConstraints.length > 0) {
+    const ctx = req.openhiContext;
+    try {
+      const result = await searchEncountersByDateOperation({
+        context: ctx,
+        periodConstraints
+      });
+      const bundle = buildSearchsetBundle(BASE_PATH.ENCOUNTER, result.entries);
+      return res.json(bundle);
+    } catch (err) {
+      return sendOperationOutcome500(
+        res,
+        err,
+        "GET /Encounter?date= search error:"
+      );
+    }
+  }
   return handleListRoute({
     req,
     res,