@metriport/shared 0.33.1 → 0.33.4

package/dist/src/domain/job/patient-job.d.ts

@@ -0,0 +1,54 @@
+import { JobStatus } from "./job-status";
+import { JobParamsCx, JobParamsOps } from "./types";
+export type PatientJob = {
+    id: string;
+    cxId: string;
+    patientId: string;
+    jobType: string;
+    jobGroupId: string;
+    requestId?: string;
+    status: JobStatus;
+    statusReason: string | undefined;
+    runUrl: string | undefined;
+    scheduledAt: Date | undefined;
+    startedAt: Date | undefined;
+    finishedAt: Date | undefined;
+    cancelledAt: Date | undefined;
+    failedAt: Date | undefined;
+    total: number;
+    successful: number;
+    failed: number;
+    paramsCx: JobParamsCx | undefined;
+    paramsOps: JobParamsOps | undefined;
+    data: unknown;
+    runtimeData: unknown;
+    createdAt: Date;
+};
+/**
+ * Used by code that needs to access the raw data from the database.
+ * @see updatePatientJobTotals()
+ */
+export declare const patientJobRawColumnNames: {
+    id: string;
+    cxId: string;
+    patientId: string;
+    jobType: string;
+    jobGroupId: string;
+    requestId: string;
+    status: string;
+    statusReason: string;
+    runUrl: string;
+    scheduledAt: string;
+    startedAt: string;
+    finishedAt: string;
+    cancelledAt: string;
+    failedAt: string;
+    total: string;
+    successful: string;
+    failed: string;
+    paramsCx: string;
+    paramsOps: string;
+    data: string;
+    runtimeData: string;
+};
+//# sourceMappingURL=patient-job.d.ts.map

package/dist/src/domain/job/patient-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patient-job.d.ts","sourceRoot":"","sources":["../../../../src/domain/job/patient-job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,IAAI,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,IAAI,GAAG,SAAS,CAAC;IAC5B,UAAU,EAAE,IAAI,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,IAAI,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC;IAClC,SAAS,EAAE,YAAY,GAAG,SAAS,CAAC;IACpC,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;CAsBpC,CAAC"}

package/dist/src/domain/job/patient-job.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patientJobRawColumnNames = void 0;
+/**
+ * Used by code that needs to access the raw data from the database.
+ * @see updatePatientJobTotals()
+ */
+exports.patientJobRawColumnNames = {
+    id: "id",
+    cxId: "cx_id",
+    patientId: "patient_id",
+    jobType: "job_type",
+    jobGroupId: "job_group_id",
+    requestId: "request_id",
+    status: "status",
+    statusReason: "status_reason",
+    runUrl: "run_url",
+    scheduledAt: "scheduled_at",
+    startedAt: "started_at",
+    finishedAt: "finished_at",
+    cancelledAt: "cancelled_at",
+    failedAt: "failed_at",
+    total: "total",
+    successful: "successful",
+    failed: "failed",
+    paramsCx: "params_cx",
+    paramsOps: "params_ops",
+    data: "data",
+    runtimeData: "runtime_data",
+};
+//# sourceMappingURL=patient-job.js.map

package/dist/src/domain/job/patient-job.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patient-job.js","sourceRoot":"","sources":["../../../../src/domain/job/patient-job.ts"],"names":[],"mappings":";;;AA4BA;;;GAGG;AACU,QAAA,wBAAwB,GAAG;IACtC,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,OAAO;IACb,SAAS,EAAE,YAAY;IACvB,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,cAAc;IAC1B,SAAS,EAAE,YAAY;IACvB,MAAM,EAAE,QAAQ;IAChB,YAAY,EAAE,eAAe;IAC7B,MAAM,EAAE,SAAS;IACjB,WAAW,EAAE,cAAc;IAC3B,SAAS,EAAE,YAAY;IACvB,UAAU,EAAE,aAAa;IACzB,WAAW,EAAE,cAAc;IAC3B,QAAQ,EAAE,WAAW;IACrB,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,YAAY;IACvB,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,cAAc;CAC5B,CAAC"}

package/dist/src/domain/job/types.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export type JobParamsCx = Record<string, string | boolean>;
+export type JobParamsOps = Record<string, string | boolean | number | object>;
+declare const failed: "failed";
+declare const successful: "successful";
+export type JobEntryStatus = typeof failed | typeof successful;
+export declare function isValidJobEntryStatus(status: string): status is JobEntryStatus;
+export declare const jobRunBodySchema: z.ZodObject<{
+    cxId: z.ZodString;
+    jobId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    cxId: string;
+    jobId: string;
+}, {
+    cxId: string;
+    jobId: string;
+}>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/domain/job/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/job/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;AAC3D,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC;AAE9E,QAAA,MAAM,MAAM,EAAG,QAAiB,CAAC;AACjC,QAAA,MAAM,UAAU,EAAG,YAAqB,CAAC;AACzC,MAAM,MAAM,cAAc,GAAG,OAAO,MAAM,GAAG,OAAO,UAAU,CAAC;AAE/D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,cAAc,CAE9E;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC"}

package/dist/src/domain/job/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobRunBodySchema = void 0;
+exports.isValidJobEntryStatus = isValidJobEntryStatus;
+const zod_1 = require("zod");
+const failed = "failed";
+const successful = "successful";
+function isValidJobEntryStatus(status) {
+    return status === "failed" || status === "successful";
+}
+exports.jobRunBodySchema = zod_1.z.object({
+    cxId: zod_1.z.string(),
+    jobId: zod_1.z.string(),
+});
+//# sourceMappingURL=types.js.map

package/dist/src/domain/job/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/domain/job/types.ts"],"names":[],"mappings":";;;AASA,sDAEC;AAXD,6BAAwB;AAKxB,MAAM,MAAM,GAAG,QAAiB,CAAC;AACjC,MAAM,UAAU,GAAG,YAAqB,CAAC;AAGzC,SAAgB,qBAAqB,CAAC,MAAc;IAClD,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,YAAY,CAAC;AACxD,CAAC;AAEY,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAC"}

package/dist/src/domain/jwt-token.d.ts

@@ -0,0 +1,6 @@
+export type JwtTokenInfo = {
+    access_token: string;
+    exp: Date;
+    id?: string;
+};
+//# sourceMappingURL=jwt-token.d.ts.map

package/dist/src/domain/jwt-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt-token.d.ts","sourceRoot":"","sources":["../../../src/domain/jwt-token.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,IAAI,CAAC;IACV,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/src/domain/jwt-token.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=jwt-token.js.map

package/dist/src/domain/jwt-token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt-token.js","sourceRoot":"","sources":["../../../src/domain/jwt-token.ts"],"names":[],"mappings":""}

package/dist/src/domain/metriport.d.ts

@@ -0,0 +1,9 @@
+export declare const metriportCompanyDetails: {
+    name: string;
+    address: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    phone: string;
+};
+//# sourceMappingURL=metriport.d.ts.map

package/dist/src/domain/metriport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metriport.d.ts","sourceRoot":"","sources":["../../../src/domain/metriport.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,uBAAuB;;;;;;;CAOnC,CAAC"}

package/dist/src/domain/metriport.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metriportCompanyDetails = void 0;
+// AKA Metriport, info
+exports.metriportCompanyDetails = {
+    name: "Metriport",
+    address: "1234 Metriport St",
+    city: "San Francisco",
+    state: "CA",
+    postalCode: "12345",
+    phone: "415-941-3282",
+};
+//# sourceMappingURL=metriport.js.map

package/dist/src/domain/metriport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metriport.js","sourceRoot":"","sources":["../../../src/domain/metriport.ts"],"names":[],"mappings":";;;AAAA,sBAAsB;AACT,QAAA,uBAAuB,GAAG;IACrC,IAAI,EAAE,WAAW;IACjB,OAAO,EAAE,mBAAmB;IAC5B,IAAI,EAAE,eAAe;IACrB,KAAK,EAAE,IAAI;IACX,UAAU,EAAE,OAAO;IACnB,KAAK,EAAE,cAAc;CACtB,CAAC"}

package/dist/src/domain/network-query/__tests__/source.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=source.test.d.ts.map

package/dist/src/domain/network-query/__tests__/source.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.test.d.ts","sourceRoot":"","sources":["../../../../../src/domain/network-query/__tests__/source.test.ts"],"names":[],"mappings":""}

package/dist/src/domain/network-query/__tests__/source.test.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const source_1 = require("../source");
+describe("network-query source", () => {
+    const mockRequestId = "test-request-id-123";
+    const mockCreatedAt = new Date("2024-01-01T10:00:00Z");
+    const mockCompletedAt = new Date("2024-01-01T10:05:00Z");
+    describe("deriveNetworkQueryStatus", () => {
+        it("should return processing when any source is processing", () => {
+            const statuses = [
+                source_1.DatasourceQueryStatus.Requested,
+                source_1.DatasourceQueryStatus.Completed,
+                source_1.DatasourceQueryStatus.Failed,
+            ];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("processing");
+        });
+        it("should return completed when all sources completed", () => {
+            const statuses = [
+                source_1.DatasourceQueryStatus.Completed,
+                source_1.DatasourceQueryStatus.Completed,
+                source_1.DatasourceQueryStatus.Completed,
+            ];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("completed");
+        });
+        it("should return failed when all sources failed", () => {
+            const statuses = [
+                source_1.DatasourceQueryStatus.Failed,
+                source_1.DatasourceQueryStatus.Failed,
+                source_1.DatasourceQueryStatus.Failed,
+            ];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("failed");
+        });
+        it("should return partial when mixed completed and failed", () => {
+            const statuses = [
+                source_1.DatasourceQueryStatus.Completed,
+                source_1.DatasourceQueryStatus.Failed,
+                source_1.DatasourceQueryStatus.Completed,
+            ];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("partial");
+        });
+        // Should we actually be throwing an error here instead of returning processing?
+        it("should handle empty array edge case", () => {
+            const result = (0, source_1.deriveNetworkQueryStatus)([]);
+            expect(result).toBe("processing");
+        });
+        it("should return processing when any status is initialized", () => {
+            const statuses = [source_1.DatasourceQueryStatus.Initialized, source_1.DatasourceQueryStatus.Completed];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("processing");
+        });
+        it("should return processing when any status is on-roster", () => {
+            const statuses = [source_1.DatasourceQueryStatus.OnRoster, source_1.DatasourceQueryStatus.Failed];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("processing");
+        });
+        it("should return processing when any status is converted", () => {
+            const statuses = [source_1.DatasourceQueryStatus.Converted, source_1.DatasourceQueryStatus.Completed];
+            const result = (0, source_1.deriveNetworkQueryStatus)(statuses);
+            expect(result).toBe("processing");
+        });
+    });
+    describe("aggregateSourcesByType via toNetworkQueryStatusDto", () => {
+        it("should omit completedAt for single processing source", () => {
+            const sources = [
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: source_1.surescriptsSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Requested,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "processing",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result.sources).toHaveLength(1);
+            expect(result.sources[0]?.completedAt).toBeUndefined();
+        });
+        it("should include latest completedAt when all sources of same type have completedAt", () => {
+            const earlierCompletedAt = new Date("2024-01-01T10:05:00Z");
+            const laterCompletedAt = new Date("2024-01-01T10:10:00Z");
+            const sources = [
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: "surescripts",
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: earlierCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: "ncpdp",
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: laterCompletedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "completed",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result.sources).toHaveLength(1);
+            expect(result.sources[0]?.type).toBe(source_1.pharmacySource);
+            expect(result.sources[0]?.completedAt).toEqual(laterCompletedAt);
+        });
+        it("should omit completedAt when some sources of same type are missing completedAt", () => {
+            const sources = [
+                {
+                    type: source_1.labSource,
+                    specificSource: "quest",
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.labSource,
+                    // NOTE(2026-01-25): We don't support labcorp right now, this is just to guard against a future case where we have multiple specific sources for a data type.
+                    specificSource: "labcorp",
+                    status: source_1.DatasourceQueryStatus.Requested,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "processing",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result.sources).toHaveLength(1);
+            expect(result.sources[0]?.type).toBe(source_1.labSource);
+            expect(result.sources[0]?.completedAt).toBeUndefined();
+        });
+        it("should use earliest startedAt when aggregating multiple sources", () => {
+            const earlierStartedAt = new Date("2024-01-01T09:00:00Z");
+            const laterStartedAt = new Date("2024-01-01T10:00:00Z");
+            const sources = [
+                {
+                    type: source_1.labSource,
+                    specificSource: "quest",
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: laterStartedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.labSource,
+                    specificSource: "labcorp",
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: earlierStartedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "completed",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result.sources).toHaveLength(1);
+            expect(result.sources[0]?.startedAt).toEqual(earlierStartedAt);
+        });
+        it("should handle multiple different source types", () => {
+            const sources = [
+                {
+                    type: source_1.hieSource,
+                    specificSource: source_1.hieSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: source_1.surescriptsSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.labSource,
+                    specificSource: source_1.questSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Requested,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "processing",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result.sources).toHaveLength(3);
+            expect(result.sources.find(s => s.type === source_1.hieSource)?.completedAt).toEqual(mockCompletedAt);
+            expect(result.sources.find(s => s.type === source_1.pharmacySource)?.completedAt).toEqual(mockCompletedAt);
+            expect(result.sources.find(s => s.type === source_1.labSource)?.completedAt).toBeUndefined();
+        });
+    });
+    describe("datasourceEntryToError", () => {
+        it("should return error when data.error exists", () => {
+            const entry = {
+                source: source_1.hieSource,
+                specificSource: source_1.hieSpecificSource,
+                status: source_1.DatasourceQueryStatus.Failed,
+                createdAt: mockCreatedAt,
+                data: {
+                    error: {
+                        httpStatus: 400,
+                        timestamp: "2024-01-01T10:05:00Z",
+                        message: "Access not enabled",
+                    },
+                },
+            };
+            const result = (0, source_1.datasourceEntryToError)(entry);
+            expect(result).toBeDefined();
+            expect(result?.source).toBe(source_1.hieSource);
+            expect(result?.httpStatus).toBe(400);
+            expect(result?.timestamp).toBe("2024-01-01T10:05:00Z");
+            expect(result?.message).toBe("Access not enabled");
+        });
+        it("should return undefined when data.error is missing", () => {
+            const entry = {
+                source: source_1.pharmacySource,
+                specificSource: source_1.surescriptsSpecificSource,
+                status: source_1.DatasourceQueryStatus.Completed,
+                createdAt: mockCreatedAt,
+                data: {
+                    metadata: { foo: "bar" },
+                },
+            };
+            const result = (0, source_1.datasourceEntryToError)(entry);
+            expect(result).toBeUndefined();
+        });
+        it("should return undefined when data is undefined", () => {
+            const entry = {
+                source: source_1.labSource,
+                specificSource: source_1.questSpecificSource,
+                status: source_1.DatasourceQueryStatus.Requested,
+                createdAt: mockCreatedAt,
+            };
+            const result = (0, source_1.datasourceEntryToError)(entry);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("network query response payload structure", () => {
+        it("should return complete NetworkQueryStatusDto structure with processing status", () => {
+            const sources = [
+                {
+                    type: source_1.hieSource,
+                    specificSource: source_1.hieSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Requested,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: source_1.surescriptsSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "processing",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            // Verify top-level structure
+            expect(result).toMatchObject({
+                requestId: expect.any(String),
+                status: expect.stringMatching(/^(processing|completed|partial|failed)$/),
+                sources: expect.any(Array),
+            });
+            expect(result.requestId).toBe(mockRequestId);
+            expect(result.status).toBe("processing");
+            expect(result.sources).toHaveLength(2);
+            // Verify each source has correct structure
+            result.sources.forEach(source => {
+                expect(source).toMatchObject({
+                    type: expect.stringMatching(/^(hie|pharmacy|lab)$/),
+                    status: expect.stringMatching(/^(processing|completed|failed)$/),
+                    startedAt: expect.any(Date),
+                });
+            });
+            // Verify HIE source (processing, no completedAt)
+            const hieSourceResult = result.sources.find(s => s.type === source_1.hieSource);
+            expect(hieSourceResult).toBeDefined();
+            expect(hieSourceResult?.status).toBe("processing");
+            expect(hieSourceResult?.completedAt).toBeUndefined();
+            if (hieSourceResult) {
+                expect("completedAt" in hieSourceResult).toBe(false);
+            }
+            // Verify pharmacy source (completed, has completedAt)
+            const pharmacySourceResult = result.sources.find(s => s.type === source_1.pharmacySource);
+            expect(pharmacySourceResult).toBeDefined();
+            expect(pharmacySourceResult?.status).toBe("completed");
+            expect(pharmacySourceResult?.completedAt).toEqual(mockCompletedAt);
+            if (pharmacySourceResult) {
+                expect("completedAt" in pharmacySourceResult).toBe(true);
+            }
+        });
+        it("should return complete NetworkQueryStatusDto structure with errors array", () => {
+            const sources = [
+                {
+                    type: source_1.hieSource,
+                    specificSource: source_1.hieSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.pharmacySource,
+                    specificSource: source_1.surescriptsSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Failed,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+                {
+                    type: source_1.labSource,
+                    specificSource: source_1.questSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Failed,
+                    startedAt: mockCreatedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "partial",
+                errors: [
+                    {
+                        source: source_1.pharmacySource,
+                        httpStatus: 400,
+                        message: "Pharmacy access not enabled for this customer",
+                        timestamp: "2024-01-01T10:00:00Z",
+                    },
+                    {
+                        source: source_1.labSource,
+                        httpStatus: 500,
+                        message: "Internal error querying lab source",
+                        timestamp: "2024-01-01T10:00:01Z",
+                    },
+                ],
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            // Verify top-level structure includes errors
+            expect(result).toMatchObject({
+                requestId: mockRequestId,
+                status: "partial",
+                sources: expect.any(Array),
+                errors: expect.any(Array),
+            });
+            // Should have all three sources in the sources array
+            expect(result.sources).toHaveLength(3);
+            // Verify completed source
+            const hieSourceResult = result.sources.find(s => s.type === source_1.hieSource);
+            expect(hieSourceResult).toMatchObject({
+                type: source_1.hieSource,
+                status: "completed",
+                completedAt: mockCompletedAt,
+            });
+            // Verify failed pharmacy source is in sources array
+            const pharmacySourceResult = result.sources.find(s => s.type === source_1.pharmacySource);
+            expect(pharmacySourceResult).toMatchObject({
+                type: source_1.pharmacySource,
+                status: "failed",
+                startedAt: mockCreatedAt,
+            });
+            expect(pharmacySourceResult?.completedAt).toBeUndefined();
+            // Verify failed lab source is in sources array
+            const labSourceResult = result.sources.find(s => s.type === source_1.labSource);
+            expect(labSourceResult).toMatchObject({
+                type: source_1.labSource,
+                status: "failed",
+                startedAt: mockCreatedAt,
+            });
+            expect(labSourceResult?.completedAt).toBeUndefined();
+            // Verify errors array has error details
+            expect(result.errors).toHaveLength(2);
+            // Verify error structure
+            result.errors?.forEach(error => {
+                expect(error).toMatchObject({
+                    source: expect.stringMatching(/^(hie|pharmacy|lab)$/),
+                    httpStatus: expect.any(Number),
+                    message: expect.any(String),
+                    timestamp: expect.any(String),
+                });
+            });
+            // Verify specific errors
+            const pharmacyError = result.errors?.find(e => e.source === source_1.pharmacySource);
+            expect(pharmacyError).toEqual({
+                source: source_1.pharmacySource,
+                httpStatus: 400,
+                message: "Pharmacy access not enabled for this customer",
+                timestamp: "2024-01-01T10:00:00Z",
+            });
+            const labError = result.errors?.find(e => e.source === source_1.labSource);
+            expect(labError).toEqual({
+                source: source_1.labSource,
+                httpStatus: 500,
+                message: "Internal error querying lab source",
+                timestamp: "2024-01-01T10:00:01Z",
+            });
+        });
+        it("should omit errors field when no errors exist", () => {
+            const sources = [
+                {
+                    type: source_1.hieSource,
+                    specificSource: source_1.hieSpecificSource,
+                    status: source_1.DatasourceQueryStatus.Completed,
+                    startedAt: mockCreatedAt,
+                    completedAt: mockCompletedAt,
+                    requestId: mockRequestId,
+                },
+            ];
+            const progress = {
+                sources,
+                requestId: mockRequestId,
+                status: "completed",
+            };
+            const result = (0, source_1.toNetworkQueryStatusDto)(progress);
+            expect(result).toMatchObject({
+                requestId: mockRequestId,
+                status: "completed",
+                sources: expect.any(Array),
+            });
+            expect(result.errors).toBeUndefined();
+            expect("errors" in result).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=source.test.js.map