@dakkitor/api-contracts 1.1.153 → 1.4.0

package/dist/curated-worker-leads/curated-worker-leads.contract.d.ts

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+export declare const EligibleWorkerAreaCountsSchema: z.ZodObject<{
+    areaCounts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    totalCount: number;
+    areaCounts: Record<string, number>;
+}, {
+    totalCount: number;
+    areaCounts: Record<string, number>;
+}>;
+export type EligibleWorkerAreaCounts = z.infer<typeof EligibleWorkerAreaCountsSchema>;
+export declare const curatedWorkerLeadsContract: {
+    areaCounts: {
+        metadata: {
+            tags: string[];
+        };
+        summary: "Eligible curated-worker counts per postcode area";
+        method: "GET";
+        path: "/v2/curated-worker-leads/area-counts";
+        responses: {
+            401: z.ZodObject<{
+                statusCode: z.ZodNumber;
+                message: z.ZodString;
+                code: z.ZodString;
+                details: z.ZodOptional<z.ZodUnknown>;
+                timestamp: z.ZodString;
+                path: z.ZodString;
+                correlationId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }>;
+            400: z.ZodObject<{
+                statusCode: z.ZodNumber;
+                message: z.ZodString;
+                code: z.ZodString;
+                details: z.ZodOptional<z.ZodUnknown>;
+                timestamp: z.ZodString;
+                path: z.ZodString;
+                correlationId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }>;
+            500: z.ZodObject<{
+                statusCode: z.ZodNumber;
+                message: z.ZodString;
+                code: z.ZodString;
+                details: z.ZodOptional<z.ZodUnknown>;
+                timestamp: z.ZodString;
+                path: z.ZodString;
+                correlationId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }>;
+            200: z.ZodObject<{
+                areaCounts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                totalCount: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                totalCount: number;
+                areaCounts: Record<string, number>;
+            }, {
+                totalCount: number;
+                areaCounts: Record<string, number>;
+            }>;
+            403: z.ZodObject<{
+                statusCode: z.ZodNumber;
+                message: z.ZodString;
+                code: z.ZodString;
+                details: z.ZodOptional<z.ZodUnknown>;
+                timestamp: z.ZodString;
+                path: z.ZodString;
+                correlationId: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }, {
+                message: string;
+                code: string;
+                path: string;
+                statusCode: number;
+                timestamp: string;
+                details?: unknown;
+                correlationId?: string | undefined;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=curated-worker-leads.contract.d.ts.map

package/dist/curated-worker-leads/curated-worker-leads.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curated-worker-leads.contract.d.ts","sourceRoot":"","sources":["../../contracts/curated-worker-leads/curated-worker-leads.contract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;;;;;EAKM,CAAC;AAClD,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBtC,CAAC"}

package/dist/curated-worker-leads/curated-worker-leads.contract.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.curatedWorkerLeadsContract = exports.EligibleWorkerAreaCountsSchema = void 0;
+const zod_openapi_1 = require("@anatine/zod-openapi");
+const core_1 = require("@ts-rest/core");
+const zod_1 = require("zod");
+const error_schemas_1 = require("../common/error-schemas");
+(0, zod_openapi_1.extendZodWithOpenApi)(zod_1.z);
+const c = (0, core_1.initContract)();
+exports.EligibleWorkerAreaCountsSchema = zod_1.z
+    .object({
+    areaCounts: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int()),
+    totalCount: zod_1.z.number().int(),
+})
+    .openapi({ title: 'EligibleWorkerAreaCounts' });
+exports.curatedWorkerLeadsContract = c.router({
+    areaCounts: {
+        method: 'GET',
+        path: '/curated-worker-leads/area-counts',
+        responses: { 200: exports.EligibleWorkerAreaCountsSchema, 403: error_schemas_1.ErrorResponseSchema },
+        summary: 'Eligible curated-worker counts per postcode area',
+        metadata: { tags: ['Curated Worker Leads'] },
+    },
+}, {
+    pathPrefix: '/v2',
+    commonResponses: {
+        400: error_schemas_1.ErrorResponseSchema,
+        401: error_schemas_1.ErrorResponseSchema,
+        403: error_schemas_1.ErrorResponseSchema,
+        500: error_schemas_1.ErrorResponseSchema,
+    },
+});

package/dist/curated-worker-leads/job-candidate-cards.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=job-candidate-cards.spec.d.ts.map

package/dist/curated-worker-leads/job-candidate-cards.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-candidate-cards.spec.d.ts","sourceRoot":"","sources":["../../contracts/curated-worker-leads/job-candidate-cards.spec.ts"],"names":[],"mappings":""}

package/dist/curated-worker-leads/job-candidate-cards.spec.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jobs_tab_contract_1 = require("./jobs-tab.contract");
+const FORBIDDEN_KEYS = [
+    'phoneNumbers',
+    'email',
+    'nino',
+    'shareCode',
+    'idDocuments',
+    'source',
+    'createdBy',
+    'createdByUserId',
+];
+describe('JobCandidateCardSchema / OwnedCandidateCardSchema', () => {
+    it('reuses the candidate cards body schema in the hydration route', () => {
+        expect(jobs_tab_contract_1.jobsTabContract.getCandidateCards.responses[200]).toBe(jobs_tab_contract_1.CandidateCardsBodySchema);
+    });
+    it('curated projection contains no sensitive keys', () => {
+        const keys = Object.keys(jobs_tab_contract_1.JobCandidateCardSchema.shape);
+        for (const forbidden of FORBIDDEN_KEYS) {
+            expect(keys).not.toContain(forbidden);
+        }
+        expect(keys).toContain('hasPhoneNumber');
+        expect(keys).toContain('firstName');
+        expect(keys).toContain('location');
+        expect(keys).toContain('trades');
+        expect(keys).toContain('qualifications');
+    });
+    it('owned projection contains no sensitive keys', () => {
+        const keys = Object.keys(jobs_tab_contract_1.OwnedCandidateCardSchema.shape);
+        for (const forbidden of FORBIDDEN_KEYS) {
+            expect(keys).not.toContain(forbidden);
+        }
+        expect(keys).toContain('hasPhoneNumber');
+    });
+    it('nested projections omit upload, phone, address, and coordinate fields', () => {
+        expect(Object.keys(jobs_tab_contract_1.JobCandidateQualificationSchema.shape)).not.toContain('proofDocumentFileId');
+        expect(Object.keys(jobs_tab_contract_1.OwnedCandidateQualificationSchema.shape)).not.toContain('proofDocumentFileId');
+        expect(Object.keys(jobs_tab_contract_1.OwnedCandidateCrewSchema.shape)).not.toContain('leadPhone');
+        const locationKeys = Object.keys(jobs_tab_contract_1.CandidateLocationSchema.shape);
+        for (const forbidden of ['address', 'latitude', 'longitude']) {
+            expect(locationKeys).not.toContain(forbidden);
+        }
+    });
+    it('parsing a full DTO strips unknown sensitive keys', () => {
+        const parsed = jobs_tab_contract_1.JobCandidateCardSchema.parse({
+            id: '7d5c0f4e-8f60-4bff-b544-111111111111',
+            firstName: 'Ana',
+            lastName: 'Pop',
+            englishLevel: 'ADVANCED',
+            nationality: 'ROMANIAN',
+            hasTools: true,
+            hasPpe: true,
+            transportation: null,
+            location: { postcode: 'E1 6AN' },
+            offerOpenness: 'OPEN',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            trades: [],
+            qualifications: [],
+            hasPhoneNumber: true,
+            phoneNumbers: [{ phoneNumber: '+441234567890' }],
+            email: 'x@y.z',
+            nino: 'QQ123456C',
+        });
+        expect(parsed).not.toHaveProperty('phoneNumbers');
+        expect(parsed).not.toHaveProperty('email');
+        expect(parsed).not.toHaveProperty('nino');
+    });
+    it('strips sensitive keys nested inside curated candidate data', () => {
+        const parsed = jobs_tab_contract_1.JobCandidateCardSchema.parse({
+            id: '7d5c0f4e-8f60-4bff-b544-111111111111',
+            firstName: 'Ana',
+            hasTools: true,
+            hasPpe: true,
+            location: {
+                postcode: 'E1 6AN',
+                postTown: 'London',
+                address: '10 Private Street',
+                latitude: 51.5,
+                longitude: -0.1,
+            },
+            offerOpenness: 'OPEN',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            qualifications: [
+                {
+                    id: '11111111-1111-4111-8111-111111111111',
+                    qualificationId: '22222222-2222-4222-8222-222222222222',
+                    qualificationTypeId: null,
+                    issueDate: null,
+                    expiryDate: null,
+                    referenceNumber: null,
+                    proofDocumentFileId: '33333333-3333-4333-8333-333333333333',
+                },
+            ],
+            hasPhoneNumber: true,
+        });
+        expect(parsed.location).not.toHaveProperty('address');
+        expect(parsed.location).not.toHaveProperty('latitude');
+        expect(parsed.location).not.toHaveProperty('longitude');
+        expect(parsed.qualifications?.[0]).not.toHaveProperty('proofDocumentFileId');
+    });
+    it('strips sensitive keys nested inside owned candidate data', () => {
+        const parsed = jobs_tab_contract_1.OwnedCandidateCardSchema.parse({
+            id: '7d5c0f4e-8f60-4bff-b544-111111111111',
+            firstName: 'Ana',
+            hasTools: true,
+            hasPpe: true,
+            offerOpenness: 'OPEN',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            qualifications: [
+                {
+                    qualificationId: '22222222-2222-4222-8222-222222222222',
+                    proofDocumentFileId: '33333333-3333-4333-8333-333333333333',
+                },
+            ],
+            crew: {
+                id: '44444444-4444-4444-8444-444444444444',
+                name: 'Crew A',
+                leadName: 'Private Lead',
+                leadPhone: '+441234567890',
+            },
+            location: {
+                postcode: 'E1 6AN',
+                address: '10 Private Street',
+                latitude: 51.5,
+                longitude: -0.1,
+            },
+            hasPhoneNumber: true,
+        });
+        expect(parsed.qualifications?.[0]).not.toHaveProperty('proofDocumentFileId');
+        expect(parsed.crew).not.toHaveProperty('leadPhone');
+        expect(parsed.crew).not.toHaveProperty('leadName');
+        expect(parsed.location).not.toHaveProperty('address');
+        expect(parsed.location).not.toHaveProperty('latitude');
+        expect(parsed.location).not.toHaveProperty('longitude');
+    });
+    it('getCandidateCards route is job-scoped', () => {
+        expect(jobs_tab_contract_1.jobsTabContract.getCandidateCards.path).toBe('/v2/curated-worker-leads/jobs/:jobId/candidate-cards');
+        expect(jobs_tab_contract_1.jobsTabContract.getCandidateCards.query.safeParse({
+            ownedIds: '7d5c0f4e-8f60-4bff-b544-111111111111',
+        }).success).toBe(true);
+        expect(Object.keys(jobs_tab_contract_1.jobsTabContract.getCandidateCards.query.shape)).toContain('ownedIds');
+        expect(Object.keys(jobs_tab_contract_1.jobsTabContract.getCandidateCards.query.shape)).not.toContain('ownIds');
+    });
+    it('setDoNotContact accepts an optional jobId', () => {
+        const body = jobs_tab_contract_1.jobsTabContract.setDoNotContact.body;
+        expect(body.safeParse({ reason: 'NOT_INTERESTED', days: 7 }).success).toBe(true);
+        expect(body.safeParse({
+            reason: 'NOT_INTERESTED',
+            days: 7,
+            jobId: '7d5c0f4e-8f60-4bff-b544-111111111111',
+        }).success).toBe(true);
+    });
+});

package/dist/curated-worker-leads/job-candidates.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=job-candidates.spec.d.ts.map

package/dist/curated-worker-leads/job-candidates.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-candidates.spec.d.ts","sourceRoot":"","sources":["../../contracts/curated-worker-leads/job-candidates.spec.ts"],"names":[],"mappings":""}

package/dist/curated-worker-leads/job-candidates.spec.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jobs_tab_contract_1 = require("./jobs-tab.contract");
+describe('JobCandidates schemas', () => {
+    const row = {
+        subjectKind: 'OWNED',
+        subjectId: '4b36e83e-9a72-4c8f-9f6d-1e2a3b4c5d6e',
+        distanceKm: 5.2,
+        driveMinutes: 22,
+        transitMinutes: 48,
+        disposition: {
+            status: 'OFFER_SENT',
+            channel: 'WHATSAPP',
+            dispositionAt: '2026-07-02T09:00:00.000Z',
+            reason: null,
+            comment: null,
+            declinedRate: null,
+            declinedRateUnit: null,
+        },
+        lastActivityAt: '2026-07-02T09:00:00.000Z',
+    };
+    const card = {
+        id: row.subjectId,
+        firstName: 'Ana',
+        lastName: 'Pop',
+        englishLevel: 'ADVANCED',
+        nationality: 'ROMANIAN',
+        hasTools: true,
+        hasPpe: true,
+        transportation: null,
+        location: null,
+        offerOpenness: 'OPEN',
+        createdAt: '2026-07-01T09:00:00.000Z',
+        updatedAt: '2026-07-02T09:00:00.000Z',
+        trades: [],
+        qualifications: [],
+        hasPhoneNumber: true,
+    };
+    it('parses a full row', () => {
+        expect(jobs_tab_contract_1.CandidateRowSchema.parse({
+            ...row,
+            contactedByViewer: true,
+            whatsappContact: {
+                agent: {
+                    id: '5c47f94f-ab83-4dc5-a8ef-2f3b4c5d6e7f',
+                    firstName: 'Alex',
+                    lastName: 'Smith',
+                },
+                contactedAt: '2026-07-02T09:00:00.000Z',
+            },
+        })).toMatchObject({
+            subjectId: row.subjectId,
+            contactedByViewer: true,
+            whatsappContact: {
+                agent: { firstName: 'Alex', lastName: 'Smith' },
+            },
+        });
+    });
+    it('parses a never-contacted row (nullables)', () => {
+        const parsed = jobs_tab_contract_1.CandidateRowSchema.parse({
+            ...row,
+            driveMinutes: null,
+            transitMinutes: null,
+            disposition: null,
+            lastActivityAt: null,
+            whatsappContact: null,
+        });
+        expect(parsed.disposition).toBeNull();
+        expect(parsed.whatsappContact).toBeNull();
+    });
+    it('parses ordered multi-channel offer evidence', () => {
+        const parsed = jobs_tab_contract_1.CandidateRowSchema.parse({
+            ...row,
+            offerChannels: ['WHATSAPP', 'PHONE'],
+            offerContactedAt: '2026-07-24T09:01:01.000Z',
+        });
+        expect(parsed.offerChannels).toEqual(['WHATSAPP', 'PHONE']);
+        expect(parsed.offerContactedAt).toBe('2026-07-24T09:01:01.000Z');
+    });
+    it('keeps pre-field candidate rows compatible', () => {
+        const parsed = jobs_tab_contract_1.CandidateRowSchema.parse(row);
+        expect(parsed.offerChannels).toBeUndefined();
+        expect(parsed.offerContactedAt).toBeUndefined();
+    });
+    it('parses the response envelope', () => {
+        const parsed = jobs_tab_contract_1.JobCandidatesResponseSchema.parse({
+            owned: [row],
+            curated: [],
+            cards: { own: [card], curated: [] },
+            totalOwned: 1,
+            totalCurated: 0,
+            page: 1,
+            pageSize: 24,
+            totalPages: 1,
+            pendingEnrichmentCount: 2,
+            workersContactedByViewerCount: 0,
+            workersContactedByOthersCount: 0,
+            dismissed: [],
+        });
+        expect(parsed.totalOwned).toBe(1);
+        expect(parsed.page).toBe(1);
+        expect(parsed.cards.own[0]?.id).toBe(row.subjectId);
+    });
+    it('requires the atomic candidate card projection', () => {
+        expect(() => jobs_tab_contract_1.JobCandidatesResponseSchema.parse({
+            owned: [row],
+            curated: [],
+            totalOwned: 1,
+            totalCurated: 0,
+            page: 1,
+            pageSize: 24,
+            totalPages: 1,
+            pendingEnrichmentCount: 0,
+            workersContactedByViewerCount: 0,
+            workersContactedByOthersCount: 0,
+            dismissed: [],
+        })).toThrow();
+    });
+    it('parses a row with bookingHistory', () => {
+        const parsed = jobs_tab_contract_1.CandidateRowSchema.parse({
+            ...row,
+            bookingHistory: {
+                workedTotal: 3,
+                workedByMe: 1,
+                noShowTotal: 1,
+                noShowByMe: 0,
+            },
+        });
+        expect(parsed.bookingHistory).toEqual({
+            workedTotal: 3,
+            workedByMe: 1,
+            noShowTotal: 1,
+            noShowByMe: 0,
+        });
+    });
+    it('parses a row without bookingHistory (pre-field cached payloads)', () => {
+        const parsed = jobs_tab_contract_1.CandidateRowSchema.parse(row);
+        expect(parsed.bookingHistory).toBeUndefined();
+    });
+});

package/dist/curated-worker-leads/job-feed-match-counts.contract.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=job-feed-match-counts.contract.spec.d.ts.map

package/dist/curated-worker-leads/job-feed-match-counts.contract.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-feed-match-counts.contract.spec.d.ts","sourceRoot":"","sources":["../../contracts/curated-worker-leads/job-feed-match-counts.contract.spec.ts"],"names":[],"mappings":""}

package/dist/curated-worker-leads/job-feed-match-counts.contract.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jobs_tab_contract_1 = require("./jobs-tab.contract");
+const id = (index) => `00000000-0000-4000-8000-${String(index).padStart(12, '0')}`;
+describe('job feed match-count batch contract', () => {
+    it('accepts a comma-separated batch of up to 200 UUIDs', () => {
+        const result = jobs_tab_contract_1.jobsTabContract.matchCounts.query.safeParse({
+            jobIds: Array.from({ length: 200 }, (_, index) => id(index)).join(','),
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects malformed IDs and batches larger than 200', () => {
+        expect(jobs_tab_contract_1.jobsTabContract.matchCounts.query.safeParse({ jobIds: `${id(1)},nope` })
+            .success).toBe(false);
+        expect(jobs_tab_contract_1.jobsTabContract.matchCounts.query.safeParse({
+            jobIds: Array.from({ length: 201 }, (_, index) => id(index)).join(','),
+        }).success).toBe(false);
+    });
+});