vet-sdk-core-ts 0.4.22 → 0.4.24

package/README.md

@@ -9,6 +9,15 @@ UHC SDK packages and must not import them.
 The SDK consumes governed browser-safe values from `vet-data-utils-ts` and
 owns gateway request construction. GW VET remains the policy authority.
 
+## Veterinary scheduling bundles
+
+The `vet-sdk-core-ts/scheduling` entrypoint extends the generic GW bundle
+boundary without changing `gdc-*`. It builds claims-first JSON:API batches,
+reads canonical `body.data[].resource` search matches and reconciles removed
+occupied Slots as pending Appointments plus durable rescheduling
+Communications. The same product extension can later be promoted for SOSChain
+or UHC/UNID after their resource policy is defined.
+
 ## Veterinary health-card issuance
 
 `issueVeterinaryHealthCardCredential(...)` accepts only an authoritative

package/dist/index.d.ts

@@ -7,4 +7,5 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./health-card-issuance.js";
+export * from "./scheduling.js";
 export * from "vet-data-utils-ts";

package/dist/index.js

@@ -7,4 +7,5 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./health-card-issuance.js";
+export * from "./scheduling.js";
 export * from "vet-data-utils-ts";

package/dist/scheduling.d.ts

@@ -0,0 +1,78 @@
+import { type VeterinarySchedulingFlatClaimsResource, type VeterinarySchedulingResourceType } from 'vet-data-utils-ts/scheduling';
+export type VeterinarySchedulingBatchMethod = 'POST' | 'PUT';
+export type VeterinarySchedulingBatch = Readonly<{
+    data: readonly Readonly<{
+        type: `${VeterinarySchedulingResourceType}-v5.0.0`;
+        resource: VeterinarySchedulingFlatClaimsResource;
+        request: Readonly<{
+            method: VeterinarySchedulingBatchMethod;
+            url: string;
+        }>;
+    }>[];
+}>;
+/**
+ * Extends the generic GW JSON:API batch boundary for VetChain scheduling.
+ * Resources are revalidated at this product boundary and remain claims-only.
+ */
+export declare function buildVeterinarySchedulingBatch(resources: readonly unknown[], method?: VeterinarySchedulingBatchMethod): VeterinarySchedulingBatch;
+/** Builds the governed claims-first search envelope accepted by GW VET. */
+export declare function buildVeterinarySchedulingSearch(resourceType: VeterinarySchedulingResourceType, claims: Readonly<Record<string, unknown>>): Readonly<{
+    data: readonly Readonly<{
+        resource: Readonly<{
+            resourceType: VeterinarySchedulingResourceType;
+            id: string;
+            meta: Readonly<{
+                claims: Readonly<Record<string, readonly string[]>>;
+            }>;
+        }>;
+    }>[];
+}>;
+/** Builds the clinic-wide `_search` envelope for responses recorded inside an inclusive time period. */
+export declare function buildVeterinaryAppointmentResponseSearchPeriod(input: Readonly<{
+    from: string;
+    to: string;
+}>): Readonly<{
+    data: readonly Readonly<{
+        resource: Readonly<{
+            resourceType: VeterinarySchedulingResourceType;
+            id: string;
+            meta: Readonly<{
+                claims: Readonly<Record<string, readonly string[]>>;
+            }>;
+        }>;
+    }>[];
+}>;
+export type VeterinaryAppointmentResponseEmailPayload = Readonly<{
+    to: string;
+    subject: string;
+    text: string;
+    metadata: Readonly<Record<string, string>>;
+}>;
+/** Converts the governed English AppointmentResponse Communication projection into an email-adapter payload. */
+export declare function convertVeterinaryAppointmentResponseCommunicationToEnglishEmail(input: Readonly<{
+    recipientEmail: string;
+    communication: unknown;
+}>): VeterinaryAppointmentResponseEmailPayload;
+/** Reads canonical GW search matches from `body.data[].resource`. */
+export declare function readVeterinarySchedulingSearch(body: unknown, expectedResourceType: VeterinarySchedulingResourceType): readonly VeterinarySchedulingFlatClaimsResource[];
+export type VeterinaryScheduleReconciliation = Readonly<{
+    appointments: readonly VeterinarySchedulingFlatClaimsResource[];
+    notifications: readonly Readonly<{
+        resourceType: 'Communication';
+        id: string;
+        meta: Readonly<{
+            claims: Readonly<Record<string, readonly string[]>>;
+        }>;
+    }>[];
+}>;
+/**
+ * Produces recoverable updates for bookings whose slots disappeared.
+ * It deliberately does not cancel: the patient receives a durable
+ * Communication and may choose another slot before a final decline.
+ */
+export declare function reconcileVeterinaryAppointmentsAfterSlotChange(input: Readonly<{
+    appointments: readonly unknown[];
+    availableSlotReferences: ReadonlySet<string>;
+    subjectReferenceFor: (appointment: VeterinarySchedulingFlatClaimsResource) => string;
+    reason: string;
+}>): VeterinaryScheduleReconciliation;

package/dist/scheduling.js

@@ -0,0 +1,112 @@
+import { buildVeterinaryAppointmentNotificationResource, normalizeVeterinarySchedulingFlatClaimsResource, } from 'vet-data-utils-ts/scheduling';
+const asArrayClaims = (claims) => Object.freeze(Object.fromEntries(Object.entries(claims).map(([name, raw]) => [
+    name,
+    Object.freeze((Array.isArray(raw) ? raw : [raw]).map(value => String(value))),
+])));
+/**
+ * Extends the generic GW JSON:API batch boundary for VetChain scheduling.
+ * Resources are revalidated at this product boundary and remain claims-only.
+ */
+export function buildVeterinarySchedulingBatch(resources, method = 'POST') {
+    return Object.freeze({
+        data: Object.freeze(resources.map(candidate => {
+            const resource = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+            return Object.freeze({
+                type: `${resource.resourceType}-v5.0.0`,
+                resource,
+                request: Object.freeze({ method, url: `${resource.resourceType}/${resource.id}` }),
+            });
+        })),
+    });
+}
+/** Builds the governed claims-first search envelope accepted by GW VET. */
+export function buildVeterinarySchedulingSearch(resourceType, claims) {
+    const resource = normalizeVeterinarySchedulingFlatClaimsResource({
+        resourceType,
+        id: 'search',
+        meta: { claims },
+    });
+    return Object.freeze({ data: Object.freeze([Object.freeze({ resource })]) });
+}
+/** Builds the clinic-wide `_search` envelope for responses recorded inside an inclusive time period. */
+export function buildVeterinaryAppointmentResponseSearchPeriod(input) {
+    const from = Date.parse(input.from);
+    const to = Date.parse(input.to);
+    if (!Number.isFinite(from) || !Number.isFinite(to) || from > to)
+        throw new Error('appointment_response_search_period_invalid');
+    return buildVeterinarySchedulingSearch('AppointmentResponse', {
+        'VeterinaryAppointmentResponse.respondedAt': [`ge${new Date(from).toISOString()}`, `le${new Date(to).toISOString()}`],
+    });
+}
+/** Converts the governed English AppointmentResponse Communication projection into an email-adapter payload. */
+export function convertVeterinaryAppointmentResponseCommunicationToEnglishEmail(input) {
+    const email = String(input.recipientEmail || '').trim().toLowerCase();
+    const resource = input.communication;
+    const claims = resource?.resourceType === 'Communication' ? resource?.meta?.claims : undefined;
+    const references = Array.isArray(claims?.['Communication.content-reference']) ? claims['Communication.content-reference'].map(String) : [];
+    const appointmentResponse = references.find((value) => value.startsWith('AppointmentResponse/'));
+    const appointment = references.find((value) => value.startsWith('Appointment/'));
+    const text = String(claims?.['Communication.text'] || '').trim();
+    const recipient = String(claims?.['Communication.recipient'] || '').trim();
+    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email) || !appointmentResponse || !appointment || !text || !recipient)
+        throw new Error('appointment_response_email_invalid');
+    return Object.freeze({ to: email, subject: 'Appointment response', text, metadata: Object.freeze({ appointmentResponse, appointment, recipient, language: 'en' }) });
+}
+/** Reads canonical GW search matches from `body.data[].resource`. */
+export function readVeterinarySchedulingSearch(body, expectedResourceType) {
+    if (!body || typeof body !== 'object' || !Array.isArray(body.data)) {
+        throw new TypeError('veterinary_scheduling_search_invalid');
+    }
+    return Object.freeze(body.data.map(entry => {
+        if (!entry || typeof entry !== 'object' || !('resource' in entry)) {
+            throw new TypeError('veterinary_scheduling_search_resource_invalid');
+        }
+        try {
+            const resource = normalizeVeterinarySchedulingFlatClaimsResource(entry.resource);
+            if (resource.resourceType !== expectedResourceType)
+                throw new Error('wrong type');
+            return resource;
+        }
+        catch {
+            throw new TypeError('veterinary_scheduling_search_resource_invalid');
+        }
+    }));
+}
+/**
+ * Produces recoverable updates for bookings whose slots disappeared.
+ * It deliberately does not cancel: the patient receives a durable
+ * Communication and may choose another slot before a final decline.
+ */
+export function reconcileVeterinaryAppointmentsAfterSlotChange(input) {
+    const appointments = [];
+    const notifications = [];
+    for (const candidate of input.appointments) {
+        const appointment = normalizeVeterinarySchedulingFlatClaimsResource(candidate);
+        if (appointment.resourceType !== 'Appointment')
+            throw new TypeError('veterinary_scheduling_appointment_required');
+        const slots = appointment.meta.claims['Appointment.slot'] ?? [];
+        if (slots.length > 0 && slots.every(slot => input.availableSlotReferences.has(slot)))
+            continue;
+        const updated = normalizeVeterinarySchedulingFlatClaimsResource({
+            ...appointment,
+            meta: { claims: {
+                    ...appointment.meta.claims,
+                    'Appointment.status': ['pending'],
+                    'VeterinaryAppointment.reschedulingReason': [input.reason],
+                } },
+        });
+        appointments.push(updated);
+        const notification = buildVeterinaryAppointmentNotificationResource({
+            id: `${appointment.id}-schedule-change`,
+            appointmentReference: `Appointment/${appointment.id}`,
+            subjectReference: input.subjectReferenceFor(appointment),
+            reason: input.reason,
+        });
+        notifications.push(Object.freeze({
+            resourceType: 'Communication',
+            id: notification.id,
+            meta: Object.freeze({ claims: asArrayClaims(notification.meta.claims) }),
+        }));
+    }
+    return Object.freeze({ appointments: Object.freeze(appointments), notifications: Object.freeze(notifications) });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-sdk-core-ts",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "description": "Browser-safe VetChain core contracts and governed animal species identifiers",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -47,6 +47,10 @@
     "./health-card-issuance": {
       "types": "./dist/health-card-issuance.d.ts",
       "default": "./dist/health-card-issuance.js"
+    },
+    "./scheduling": {
+      "types": "./dist/scheduling.d.ts",
+      "default": "./dist/scheduling.js"
     }
   },
   "files": [
@@ -72,6 +76,6 @@
   "dependencies": {
     "@noble/hashes": "^2.2.0",
     "gdc-common-utils-ts": "2.9.10",
-    "vet-data-utils-ts": "0.5.9"
+    "vet-data-utils-ts": "0.5.13"
   }
 }