@d19n/youfibre-odin-sdk 2.0.103-beta.8 → 2.0.103-beta.9

package/dist/wholesale-provider/interface.d.ts

@@ -1,4 +1,37 @@
+/**
+ * WholesaleProvider — strategy-dispatchable interface for wholesale supplier
+ * integrations (Netomnia today, VMO2 from July 2026).
+ *
+ * **Architecture (T-20260508-009/010 — confirmed with Frank 2026-05-09 as
+ * "Path B / first step"):**
+ *
+ * Methods take YF-context arguments (orderId, principal, etc.) — matching
+ * the existing NET module method signatures. Each provider implementation
+ * builds the supplier-specific wire request internally from this YF context.
+ *
+ * Rationale:
+ *   - Existing NET module methods take YF context, not wire DTOs. The SDK
+ *     provider abstracts the supplier dispatch layer, not the DTO-building.
+ *   - Method names align with VMO2 spec where it makes sense (`createOrder`,
+ *     `cancelOrder`, etc.) so call-site vocabulary doesn't change when the
+ *     provider switches.
+ *   - When VMO2 ships, Vmo2Provider implements the same method names with
+ *     args that may differ slightly. Frank's framing: "we adjust function
+ *     arguments, nothing beyond that — we map X to Y and get the same result."
+ *
+ * **Trade-off accepted:** the interface is shaped after NET reality, not
+ * VMO2. That keeps Phase 0 a strict drop-in replacement. We can standardize
+ * args further once VMO2 ships if a tighter cross-provider abstraction
+ * proves valuable.
+ *
+ * **Type pragmatics:** principal/options/return values use `unknown` /
+ * `Record<string, unknown>` so the SDK doesn't need to depend on
+ * NestJS-decorated entity types. Modules cast at the wiring boundary (where
+ * full types are available).
+ */
 import type { VMO2OrderNotification, VMO2SMRNotification } from './types/vmo2';
+import type { FibreCafeServiceAvailability200, FibreCafeAvailableAppointments200, FibreCafeReserveAppointment201, FibreCafeScheduleServiceWorkOrder201, FibreCafeRescheduleServiceWorkOrder200, FibreCafeOrderCreate202, FibreCafeOrderAmendAccept202, FibreCafeKciDto } from './types/fibrecafe';
+import type { OrderRecord } from '../records-v2/OrderRecord';
 /**
  * Reasons a cancellation request can be made (NET wire-level enum value
  * passed through to the FibreCafe gateway).
@@ -53,8 +86,8 @@ export interface AmendAppointmentArgs {
     yfWorkOrderId: string;
     supplierAppointmentReference: string;
 }
-export interface SyncWorkOrderToSupplierArgs {
-    principal: unknown;
+export interface SyncWorkOrderToSupplierArgs<TPrincipal = unknown> {
+    principal: TPrincipal;
     yfOrderId: string;
     yfWorkOrderId: string;
     yfChangeReason: {
@@ -86,26 +119,41 @@ export interface UpdateOrderExternalRefArgs {
  * Returns are typed loosely — modules know the return shape via the dep
  * function they wire in.
  */
-export interface WholesaleProvider {
-    searchAddress(uprn: number): Promise<unknown>;
-    listAppointments(args: ListAppointmentsArgs): Promise<unknown>;
-    reserveAppointment(args: ReserveAppointmentArgs): Promise<unknown>;
-    scheduleServiceWorkOrder(args: ScheduleServiceWorkOrderArgs): Promise<unknown>;
-    rescheduleServiceWorkOrder(args: RescheduleServiceWorkOrderArgs): Promise<unknown>;
-    amendAppointment(args: AmendAppointmentArgs): Promise<unknown>;
-    createOrder(principal: unknown, orderId: string, options?: CreateOrderOptions): Promise<unknown>;
-    /** Tier-change CoS — wraps `createModifyOrderForYfOrder` style args. */
-    amendOrder(principal: unknown, yfOrderId: string): Promise<unknown>;
+/**
+ * Generic in `TPrincipal` so call sites get full typing on the user/org
+ * principal that NestJS injects via the `@Principal()` decorator. Modules
+ * specialize at the wiring boundary:
+ *
+ * ```ts
+ * class WholesaleProviderFactory {
+ *   constructor(@Inject(...) private netomnia: WholesaleProvider<OrganizationUserEntity>) {}
+ *   get(...): WholesaleProvider<OrganizationUserEntity> { ... }
+ * }
+ * ```
+ *
+ * Default `TPrincipal = unknown` lets the SDK compile standalone without
+ * tenant-specific type imports.
+ */
+export interface WholesaleProvider<TPrincipal = unknown> {
+    searchAddress(uprn: number): Promise<FibreCafeServiceAvailability200>;
+    listAppointments(args: ListAppointmentsArgs): Promise<FibreCafeAvailableAppointments200>;
+    reserveAppointment(args: ReserveAppointmentArgs): Promise<FibreCafeReserveAppointment201>;
+    scheduleServiceWorkOrder(args: ScheduleServiceWorkOrderArgs): Promise<FibreCafeScheduleServiceWorkOrder201>;
+    rescheduleServiceWorkOrder(args: RescheduleServiceWorkOrderArgs): Promise<FibreCafeRescheduleServiceWorkOrder200>;
+    amendAppointment(args: AmendAppointmentArgs): Promise<FibreCafeOrderAmendAccept202>;
+    createOrder(principal: TPrincipal, orderId: string, options?: CreateOrderOptions): Promise<FibreCafeOrderCreate202>;
+    /** Tier-change CoS — wraps `createModifyOrderForYfOrder` style args. Returns null when already at target SKU. */
+    amendOrder(principal: TPrincipal, yfOrderId: string): Promise<FibreCafeOrderCreate202 | null>;
     /** Pre-install cancel of an in-flight provide order. */
-    cancelOrder(yfOrderId: string, reasonCode: CancellationReasonCode): Promise<unknown>;
+    cancelOrder(yfOrderId: string, reasonCode: CancellationReasonCode): Promise<FibreCafeOrderCreate202>;
     /** Active-customer cease (post-Active churn / OTS-losing). */
-    ceaseOrder(yfOrderId: string, serviceId: string): Promise<unknown>;
+    ceaseOrder(yfOrderId: string, serviceId: string): Promise<FibreCafeOrderCreate202>;
     /** Inbound supplier KCI / notification handler. */
-    receiveKci(principal: unknown, dto: unknown): Promise<void>;
+    receiveKci(principal: TPrincipal, dto: FibreCafeKciDto): Promise<void>;
     /** Outbound YF→supplier WO sync (cancel propagation, etc.). */
-    syncWorkOrderToSupplier(args: SyncWorkOrderToSupplierArgs): Promise<unknown>;
+    syncWorkOrderToSupplier(args: SyncWorkOrderToSupplierArgs<TPrincipal>): Promise<void>;
     /** Inbound supplier→YF WO change application (post-receiveKci). */
-    syncWorkOrderFromSupplier(order: unknown, dto: unknown): Promise<unknown>;
+    syncWorkOrderFromSupplier(order: OrderRecord, dto: FibreCafeKciDto): Promise<void>;
     retrieveServiceIdByUprn(uprn: number): Promise<string | null>;
     updateOrderExternalRef(args: UpdateOrderExternalRefArgs): Promise<void>;
     /**

package/dist/wholesale-provider/providers/netomnia-provider.d.ts

@@ -29,6 +29,8 @@
  */
 import type { WholesaleProvider, CreateOrderOptions, CancellationReasonCode, ReserveAppointmentArgs, ListAppointmentsArgs, ScheduleServiceWorkOrderArgs, RescheduleServiceWorkOrderArgs, AmendAppointmentArgs, SyncWorkOrderToSupplierArgs, UpdateOrderExternalRefArgs } from '../interface';
 import type { VMO2OrderNotification, VMO2SMRNotification } from '../types/vmo2';
+import type { FibreCafeServiceAvailability200, FibreCafeAvailableAppointments200, FibreCafeReserveAppointment201, FibreCafeScheduleServiceWorkOrder201, FibreCafeRescheduleServiceWorkOrder200, FibreCafeOrderCreate202, FibreCafeOrderAmendAccept202, FibreCafeKciDto } from '../types/fibrecafe';
+import type { OrderRecord } from '../../records-v2/OrderRecord';
 /**
  * Function-bag of dependencies the NetomniaProvider delegates to.
  *
@@ -48,43 +50,43 @@ import type { VMO2OrderNotification, VMO2SMRNotification } from '../types/vmo2';
  *   }
  * ```
  */
-export interface NetomniaProviderDeps {
-    searchAddress: (uprn: number) => Promise<unknown>;
-    listAppointments: (args: ListAppointmentsArgs) => Promise<unknown>;
-    reserveAppointment: (args: ReserveAppointmentArgs) => Promise<unknown>;
-    scheduleServiceWorkOrder: (args: ScheduleServiceWorkOrderArgs) => Promise<unknown>;
-    rescheduleServiceWorkOrder: (args: RescheduleServiceWorkOrderArgs) => Promise<unknown>;
-    amendAppointment: (args: AmendAppointmentArgs) => Promise<unknown>;
-    createOrder: (principal: unknown, orderId: string, options?: CreateOrderOptions) => Promise<unknown>;
-    amendOrder: (principal: unknown, yfOrderId: string) => Promise<unknown>;
-    cancelOrder: (yfOrderId: string, reasonCode: CancellationReasonCode) => Promise<unknown>;
-    ceaseOrder: (yfOrderId: string, serviceId: string) => Promise<unknown>;
-    receiveKci: (principal: unknown, dto: unknown) => Promise<void>;
-    syncWorkOrderToSupplier: (args: SyncWorkOrderToSupplierArgs) => Promise<unknown>;
-    syncWorkOrderFromSupplier: (order: unknown, dto: unknown) => Promise<unknown>;
+export interface NetomniaProviderDeps<TPrincipal = unknown> {
+    searchAddress: (uprn: number) => Promise<FibreCafeServiceAvailability200>;
+    listAppointments: (args: ListAppointmentsArgs) => Promise<FibreCafeAvailableAppointments200>;
+    reserveAppointment: (args: ReserveAppointmentArgs) => Promise<FibreCafeReserveAppointment201>;
+    scheduleServiceWorkOrder: (args: ScheduleServiceWorkOrderArgs) => Promise<FibreCafeScheduleServiceWorkOrder201>;
+    rescheduleServiceWorkOrder: (args: RescheduleServiceWorkOrderArgs) => Promise<FibreCafeRescheduleServiceWorkOrder200>;
+    amendAppointment: (args: AmendAppointmentArgs) => Promise<FibreCafeOrderAmendAccept202>;
+    createOrder: (principal: TPrincipal, orderId: string, options?: CreateOrderOptions) => Promise<FibreCafeOrderCreate202>;
+    amendOrder: (principal: TPrincipal, yfOrderId: string) => Promise<FibreCafeOrderCreate202 | null>;
+    cancelOrder: (yfOrderId: string, reasonCode: CancellationReasonCode) => Promise<FibreCafeOrderCreate202>;
+    ceaseOrder: (yfOrderId: string, serviceId: string) => Promise<FibreCafeOrderCreate202>;
+    receiveKci: (principal: TPrincipal, dto: FibreCafeKciDto) => Promise<void>;
+    syncWorkOrderToSupplier: (args: SyncWorkOrderToSupplierArgs<TPrincipal>) => Promise<void>;
+    syncWorkOrderFromSupplier: (order: OrderRecord, dto: FibreCafeKciDto) => Promise<void>;
     retrieveServiceIdByUprn: (uprn: number) => Promise<string | null>;
     updateOrderExternalRef: (args: UpdateOrderExternalRefArgs) => Promise<void>;
 }
 declare type OrderNotificationHandler = (n: VMO2OrderNotification) => Promise<void>;
 declare type SMRNotificationHandler = (n: VMO2SMRNotification) => Promise<void>;
-export declare class NetomniaProvider implements WholesaleProvider {
+export declare class NetomniaProvider<TPrincipal = unknown> implements WholesaleProvider<TPrincipal> {
     private readonly deps;
     private readonly orderHandlers;
     private readonly smrHandlers;
-    constructor(deps: NetomniaProviderDeps);
-    searchAddress(uprn: number): Promise<unknown>;
-    listAppointments(args: ListAppointmentsArgs): Promise<unknown>;
-    reserveAppointment(args: ReserveAppointmentArgs): Promise<unknown>;
-    scheduleServiceWorkOrder(args: ScheduleServiceWorkOrderArgs): Promise<unknown>;
-    rescheduleServiceWorkOrder(args: RescheduleServiceWorkOrderArgs): Promise<unknown>;
-    amendAppointment(args: AmendAppointmentArgs): Promise<unknown>;
-    createOrder(principal: unknown, orderId: string, options?: CreateOrderOptions): Promise<unknown>;
-    amendOrder(principal: unknown, yfOrderId: string): Promise<unknown>;
-    cancelOrder(yfOrderId: string, reasonCode: CancellationReasonCode): Promise<unknown>;
-    ceaseOrder(yfOrderId: string, serviceId: string): Promise<unknown>;
-    receiveKci(principal: unknown, dto: unknown): Promise<void>;
-    syncWorkOrderToSupplier(args: SyncWorkOrderToSupplierArgs): Promise<unknown>;
-    syncWorkOrderFromSupplier(order: unknown, dto: unknown): Promise<unknown>;
+    constructor(deps: NetomniaProviderDeps<TPrincipal>);
+    searchAddress(uprn: number): Promise<FibreCafeServiceAvailability200>;
+    listAppointments(args: ListAppointmentsArgs): Promise<FibreCafeAvailableAppointments200>;
+    reserveAppointment(args: ReserveAppointmentArgs): Promise<FibreCafeReserveAppointment201>;
+    scheduleServiceWorkOrder(args: ScheduleServiceWorkOrderArgs): Promise<FibreCafeScheduleServiceWorkOrder201>;
+    rescheduleServiceWorkOrder(args: RescheduleServiceWorkOrderArgs): Promise<FibreCafeRescheduleServiceWorkOrder200>;
+    amendAppointment(args: AmendAppointmentArgs): Promise<FibreCafeOrderAmendAccept202>;
+    createOrder(principal: TPrincipal, orderId: string, options?: CreateOrderOptions): Promise<FibreCafeOrderCreate202>;
+    amendOrder(principal: TPrincipal, yfOrderId: string): Promise<FibreCafeOrderCreate202>;
+    cancelOrder(yfOrderId: string, reasonCode: CancellationReasonCode): Promise<FibreCafeOrderCreate202>;
+    ceaseOrder(yfOrderId: string, serviceId: string): Promise<FibreCafeOrderCreate202>;
+    receiveKci(principal: TPrincipal, dto: FibreCafeKciDto): Promise<void>;
+    syncWorkOrderToSupplier(args: SyncWorkOrderToSupplierArgs<TPrincipal>): Promise<void>;
+    syncWorkOrderFromSupplier(order: OrderRecord, dto: FibreCafeKciDto): Promise<void>;
     retrieveServiceIdByUprn(uprn: number): Promise<string>;
     updateOrderExternalRef(args: UpdateOrderExternalRefArgs): Promise<void>;
     onOrderNotification(handler: OrderNotificationHandler): void;

package/dist/wholesale-provider/test/netomnia-provider.spec.js

@@ -43,69 +43,127 @@ function brand(s) {
     return s;
 }
 /**
- * Build deps that record their call args + return a sentinel value. Each
- * dep is identical-shape to the corresponding WholesaleProvider method so
- * the pass-through pattern can be tested.
+ * Stubs each dep with a typed canned return so the pass-through pattern
+ * can be tested via identity equality (`result === stubs.searchAddress`)
+ * without resorting to `as unknown` casts.
  */
 function buildDeps() {
     const log = [];
-    const sentinel = Symbol('NET-RETURN');
-    const record = (method) => (...args) => {
-        log.push({ method, args });
-        return Promise.resolve(sentinel);
-    };
-    const recordVoid = (method) => (...args) => {
-        log.push({ method, args });
-        return Promise.resolve(undefined);
+    const stubs = {
+        searchAddress: {
+            address: { identifier: { id: 'UPRN-1', type: 'UPRN' } },
+            serviceSpecifications: [],
+        },
+        listAppointments: { availableTimeslots: [] },
+        reserveAppointment: {
+            id: 'A1',
+            supplierReference: 'NET-A1',
+            address: { id: 'X', type: 'UPRN' },
+            serviceSpecification: { id: 'fttp' },
+            timeslot: {
+                timeslotStartDateTime: '2026-06-01T08:00:00Z',
+                timeslotEndDateTime: '2026-06-01T13:00:00Z',
+            },
+        },
+        scheduleServiceWorkOrder: { workOrderId: 'WO-1', appointmentId: 'APT-1' },
+        rescheduleServiceWorkOrder: { workOrderId: 'WO-1', appointmentId: 'APT-2' },
+        amendAppointment: {},
+        createOrder: {},
+        amendOrder: {},
+        cancelOrder: {},
+        ceaseOrder: {},
     };
     const deps = {
-        searchAddress: record('searchAddress'),
-        listAppointments: record('listAppointments'),
-        reserveAppointment: record('reserveAppointment'),
-        scheduleServiceWorkOrder: record('scheduleServiceWorkOrder'),
-        rescheduleServiceWorkOrder: record('rescheduleServiceWorkOrder'),
-        amendAppointment: record('amendAppointment'),
-        createOrder: record('createOrder'),
-        amendOrder: record('amendOrder'),
-        cancelOrder: record('cancelOrder'),
-        ceaseOrder: record('ceaseOrder'),
-        receiveKci: recordVoid('receiveKci'),
-        syncWorkOrderToSupplier: record('syncWorkOrderToSupplier'),
-        syncWorkOrderFromSupplier: record('syncWorkOrderFromSupplier'),
+        searchAddress: (uprn) => {
+            log.push({ method: 'searchAddress', args: [uprn] });
+            return Promise.resolve(stubs.searchAddress);
+        },
+        listAppointments: (args) => {
+            log.push({ method: 'listAppointments', args: [args] });
+            return Promise.resolve(stubs.listAppointments);
+        },
+        reserveAppointment: (args) => {
+            log.push({ method: 'reserveAppointment', args: [args] });
+            return Promise.resolve(stubs.reserveAppointment);
+        },
+        scheduleServiceWorkOrder: (args) => {
+            log.push({ method: 'scheduleServiceWorkOrder', args: [args] });
+            return Promise.resolve(stubs.scheduleServiceWorkOrder);
+        },
+        rescheduleServiceWorkOrder: (args) => {
+            log.push({ method: 'rescheduleServiceWorkOrder', args: [args] });
+            return Promise.resolve(stubs.rescheduleServiceWorkOrder);
+        },
+        amendAppointment: (args) => {
+            log.push({ method: 'amendAppointment', args: [args] });
+            return Promise.resolve(stubs.amendAppointment);
+        },
+        createOrder: (principal, orderId, options) => {
+            log.push({ method: 'createOrder', args: [principal, orderId, options] });
+            return Promise.resolve(stubs.createOrder);
+        },
+        amendOrder: (principal, yfOrderId) => {
+            log.push({ method: 'amendOrder', args: [principal, yfOrderId] });
+            return Promise.resolve(stubs.amendOrder);
+        },
+        cancelOrder: (yfOrderId, reasonCode) => {
+            log.push({ method: 'cancelOrder', args: [yfOrderId, reasonCode] });
+            return Promise.resolve(stubs.cancelOrder);
+        },
+        ceaseOrder: (yfOrderId, serviceId) => {
+            log.push({ method: 'ceaseOrder', args: [yfOrderId, serviceId] });
+            return Promise.resolve(stubs.ceaseOrder);
+        },
+        receiveKci: (principal, dto) => {
+            log.push({ method: 'receiveKci', args: [principal, dto] });
+            return Promise.resolve();
+        },
+        syncWorkOrderToSupplier: (args) => {
+            log.push({ method: 'syncWorkOrderToSupplier', args: [args] });
+            return Promise.resolve();
+        },
+        syncWorkOrderFromSupplier: (order, dto) => {
+            log.push({ method: 'syncWorkOrderFromSupplier', args: [order, dto] });
+            return Promise.resolve();
+        },
         retrieveServiceIdByUprn: (uprn) => {
             log.push({ method: 'retrieveServiceIdByUprn', args: [uprn] });
             return Promise.resolve('NET-SVC-1');
         },
-        updateOrderExternalRef: recordVoid('updateOrderExternalRef'),
+        updateOrderExternalRef: (args) => {
+            log.push({ method: 'updateOrderExternalRef', args: [args] });
+            return Promise.resolve();
+        },
     };
-    return { deps, log, sentinel };
+    return { deps, log, stubs };
 }
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
         console.log('NetomniaProvider — pass-through delegation tests\n');
         console.log('Test: searchAddress delegates to deps');
         {
-            const { deps, log, sentinel } = buildDeps();
+            const { deps, log, stubs } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
             const result = yield p.searchAddress(123);
             assert('called once', log.length === 1);
             assert('correct method', log[0].method === 'searchAddress');
             assert('args forwarded', JSON.stringify(log[0].args) === JSON.stringify([123]));
-            assert('return forwarded', result === sentinel);
+            assert('return forwarded', result === stubs.searchAddress);
         }
         console.log('Test: listAppointments delegates to deps');
         {
-            const { deps, log } = buildDeps();
+            const { deps, log, stubs } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
             const args = { uprn: 123, start: '2026-06-01', appointmentPurpose: 'PROVIDE' };
-            yield p.listAppointments(args);
+            const result = yield p.listAppointments(args);
             assert('called once', log.length === 1);
             assert('correct method', log[0].method === 'listAppointments');
             assert('args forwarded', log[0].args[0] === args);
+            assert('return forwarded', result === stubs.listAppointments);
         }
         console.log('Test: reserveAppointment delegates to deps');
         {
-            const { deps, log } = buildDeps();
+            const { deps, log, stubs } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
             const args = {
                 yfAppointmentId: 'APT-1',
@@ -117,10 +175,11 @@ function run() {
                 woProperties: {},
                 flow: 'FIRST_TIME_BOOKING',
             };
-            yield p.reserveAppointment(args);
+            const result = yield p.reserveAppointment(args);
             assert('called once', log.length === 1);
             assert('correct method', log[0].method === 'reserveAppointment');
             assert('args forwarded', log[0].args[0] === args);
+            assert('return forwarded', result === stubs.reserveAppointment);
         }
         console.log('Test: scheduleServiceWorkOrder delegates to deps');
         {
@@ -164,7 +223,7 @@ function run() {
         }
         console.log('Test: createOrder delegates to deps with all args (principal, orderId, options)');
         {
-            const { deps, log, sentinel } = buildDeps();
+            const { deps, log, stubs } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
             const principal = { id: 'user-1' };
             const opts = { doNotCreateServiceAppointment: true };
@@ -174,7 +233,7 @@ function run() {
             assert('principal forwarded', log[0].args[0] === principal);
             assert('orderId forwarded', log[0].args[1] === 'ORD-1');
             assert('options forwarded', log[0].args[2] === opts);
-            assert('return forwarded', result === sentinel);
+            assert('return forwarded', result === stubs.createOrder);
         }
         console.log('Test: createOrder forwards undefined options correctly');
         {
@@ -218,7 +277,13 @@ function run() {
             const { deps, log } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
             const principal = { id: 'user-1' };
-            const dto = { id: 'kci-1', sequenceNumber: 1 };
+            // Minimal valid FibreCafeKciDto fixture.
+            const dto = {
+                id: 'kci-1',
+                sequenceNumber: 1,
+                issuedOn: '2026-05-09T00:00:00Z',
+                reasonCode: 'ACKNOWLEDGED',
+            };
             yield p.receiveKci(principal, dto);
             assert('called once', log.length === 1);
             assert('correct method', log[0].method === 'receiveKci');
@@ -243,11 +308,22 @@ function run() {
         {
             const { deps, log } = buildDeps();
             const p = new netomnia_provider_1.NetomniaProvider(deps);
+            // Test fixtures: pass-through tests treat these values as opaque; we
+            // assert reference equality, not structural equality. Casting a minimal
+            // shape to the expected types is acceptable here — the alternative is
+            // constructing 80+ OrderRecord properties for no semantic value.
             const order = { id: 'ORD-1' };
-            const dto = { id: 'kci-1' };
+            const dto = {
+                id: 'kci-1',
+                sequenceNumber: 1,
+                issuedOn: '2026-05-09T00:00:00Z',
+                reasonCode: 'UPDATE',
+            };
             yield p.syncWorkOrderFromSupplier(order, dto);
             assert('called once', log.length === 1);
             assert('correct method', log[0].method === 'syncWorkOrderFromSupplier');
+            assert('order reference forwarded', log[0].args[0] === order);
+            assert('dto reference forwarded', log[0].args[1] === dto);
         }
         console.log('Test: retrieveServiceIdByUprn delegates to deps');
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d19n/youfibre-odin-sdk",
-  "version": "2.0.103-beta.8",
+  "version": "2.0.103-beta.9",
   "description": "",
   "author": "@d19n",
   "license": "UNLICENSED",