@dakkitor/api-contracts 1.1.153 → 1.4.0

package/dist/bookings/bookings.contract.spec.d.ts

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

package/dist/bookings/bookings.contract.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookings.contract.spec.d.ts","sourceRoot":"","sources":["../../contracts/bookings/bookings.contract.spec.ts"],"names":[],"mappings":""}

package/dist/bookings/bookings.contract.spec.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bookings_contract_1 = require("./bookings.contract");
+describe('BookingJobSummarySchema', () => {
+    it('accepts legacy jobs without a trade', () => {
+        expect(bookings_contract_1.BookingJobSummarySchema.safeParse({
+            id: '00000000-0000-4000-8000-000000000001',
+            tradeId: null,
+        }).success).toBe(true);
+    });
+});

package/dist/bookings/job-lock.spec.d.ts

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

package/dist/bookings/job-lock.spec.d.ts.map

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

package/dist/bookings/job-lock.spec.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bookings_contract_1 = require("./bookings.contract");
+// Fixed "now" so the date math is deterministic.
+const NOW = new Date('2026-05-27T10:00:00Z');
+const daysBefore = (n) => {
+    const d = new Date(NOW);
+    d.setUTCDate(d.getUTCDate() - n);
+    return d.toISOString().split('T')[0]; // 'YYYY-MM-DD'
+};
+describe('isBookingJobLocked', () => {
+    it('exposes the threshold as 3', () => {
+        expect(bookings_contract_1.MAX_ACTIVES_FOR_JOB_CHANGE).toBe(3);
+    });
+    it('does not lock ATTEMPT regardless of how old the start date is', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'ATTEMPT', startDate: daysBefore(365), endDate: null, now: NOW })).toBe(false);
+    });
+    it('does not lock FAILED_START or CANCELLED even with old history', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'FAILED_START', startDate: daysBefore(30), endDate: null, now: NOW })).toBe(false);
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'CANCELLED', startDate: daysBefore(30), endDate: null, now: NOW })).toBe(false);
+    });
+    it('IN_PROGRESS started today is not locked (1 active day)', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'IN_PROGRESS', startDate: daysBefore(0), endDate: null, now: NOW })).toBe(false);
+    });
+    it('IN_PROGRESS at the boundary (2 days past start = 3 active days) is not locked', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'IN_PROGRESS', startDate: daysBefore(2), endDate: null, now: NOW })).toBe(false);
+    });
+    it('IN_PROGRESS just over the boundary (3 days past start = 4 active days) is locked', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'IN_PROGRESS', startDate: daysBefore(3), endDate: null, now: NOW })).toBe(true);
+    });
+    it('FINISHED_THE_JOB locks when it ran more than the threshold of days', () => {
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'FINISHED_THE_JOB', startDate: daysBefore(10), endDate: null, now: NOW })).toBe(true);
+    });
+    it('endDate cap keeps a short finished booking correctable even if it finished a while ago', () => {
+        // Started 100 days ago, worked only 2 days (endDate = start + 1) -> 2 active days -> not locked.
+        const start = daysBefore(100);
+        const end = (() => {
+            const d = new Date(start + 'T00:00:00Z');
+            d.setUTCDate(d.getUTCDate() + 1);
+            return d.toISOString().split('T')[0];
+        })();
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'FINISHED_THE_JOB', startDate: start, endDate: end, now: NOW })).toBe(false);
+    });
+    it('treats endDate === today as still-running (endRef = today), not locked at the boundary', () => {
+        // Started 2 days ago, endDate today -> 3 active days -> not locked.
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'FINISHED_THE_JOB', startDate: daysBefore(2), endDate: daysBefore(0), now: NOW })).toBe(false);
+    });
+    it('a future start date does not lock', () => {
+        const future = (() => {
+            const d = new Date(NOW);
+            d.setUTCDate(d.getUTCDate() + 5);
+            return d.toISOString().split('T')[0];
+        })();
+        expect((0, bookings_contract_1.isBookingJobLocked)({ category: 'IN_PROGRESS', startDate: future, endDate: null, now: NOW })).toBe(false);
+    });
+});

package/dist/bot-parse-cache/bot-parse-cache.contract.d.ts

@@ -0,0 +1,232 @@
+import { z } from 'zod';
+export declare const BotParseCacheLookupBodySchema: z.ZodObject<{
+    rawText: z.ZodString;
+    parserVersion: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    rawText: string;
+    parserVersion: string;
+}, {
+    rawText: string;
+    parserVersion: string;
+}>;
+export declare const BotParseCacheLookupResponseSchema: z.ZodDiscriminatedUnion<"hit", [z.ZodObject<{
+    hit: z.ZodLiteral<true>;
+    layer: z.ZodEnum<["L1", "L2"]>;
+    parsedJob: z.ZodArray<z.ZodUnknown, "many">;
+    sim: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    hit: true;
+    layer: "L1" | "L2";
+    parsedJob: unknown[];
+    sim: number | null;
+}, {
+    hit: true;
+    layer: "L1" | "L2";
+    parsedJob: unknown[];
+    sim: number | null;
+}>, z.ZodObject<{
+    hit: z.ZodLiteral<false>;
+}, "strip", z.ZodTypeAny, {
+    hit: false;
+}, {
+    hit: false;
+}>]>;
+export declare const BotParseCachePersistBodySchema: z.ZodObject<{
+    rawText: z.ZodString;
+    parsedJob: z.ZodArray<z.ZodUnknown, "many">;
+    parserVersion: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    rawText: string;
+    parserVersion: string;
+    parsedJob: unknown[];
+}, {
+    rawText: string;
+    parserVersion: string;
+    parsedJob: unknown[];
+}>;
+export declare const BotParseCachePersistResponseSchema: z.ZodObject<{
+    written: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    written: boolean;
+}, {
+    written: boolean;
+}>;
+export type BotParseCacheLookupBody = z.infer<typeof BotParseCacheLookupBodySchema>;
+export type BotParseCacheLookupResponse = z.infer<typeof BotParseCacheLookupResponseSchema>;
+export type BotParseCachePersistBody = z.infer<typeof BotParseCachePersistBodySchema>;
+export type BotParseCachePersistResponse = z.infer<typeof BotParseCachePersistResponseSchema>;
+export declare const botParseCacheContract: {
+    lookup: {
+        metadata: {
+            tags: string[];
+        };
+        summary: "Look up cached parsed job by raw text (exact + fuzzy)";
+        method: "POST";
+        body: z.ZodObject<{
+            rawText: z.ZodString;
+            parserVersion: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            rawText: string;
+            parserVersion: string;
+        }, {
+            rawText: string;
+            parserVersion: string;
+        }>;
+        path: "/v2/bot-parse-cache/lookup";
+        responses: {
+            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.ZodDiscriminatedUnion<"hit", [z.ZodObject<{
+                hit: z.ZodLiteral<true>;
+                layer: z.ZodEnum<["L1", "L2"]>;
+                parsedJob: z.ZodArray<z.ZodUnknown, "many">;
+                sim: z.ZodNullable<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                hit: true;
+                layer: "L1" | "L2";
+                parsedJob: unknown[];
+                sim: number | null;
+            }, {
+                hit: true;
+                layer: "L1" | "L2";
+                parsedJob: unknown[];
+                sim: number | null;
+            }>, z.ZodObject<{
+                hit: z.ZodLiteral<false>;
+            }, "strip", z.ZodTypeAny, {
+                hit: false;
+            }, {
+                hit: false;
+            }>]>;
+        };
+    };
+    persist: {
+        metadata: {
+            tags: string[];
+        };
+        summary: "Persist a parsed job for future cache reuse";
+        method: "POST";
+        body: z.ZodObject<{
+            rawText: z.ZodString;
+            parsedJob: z.ZodArray<z.ZodUnknown, "many">;
+            parserVersion: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            rawText: string;
+            parserVersion: string;
+            parsedJob: unknown[];
+        }, {
+            rawText: string;
+            parserVersion: string;
+            parsedJob: unknown[];
+        }>;
+        path: "/v2/bot-parse-cache/persist";
+        responses: {
+            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<{
+                written: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                written: boolean;
+            }, {
+                written: boolean;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=bot-parse-cache.contract.d.ts.map

package/dist/bot-parse-cache/bot-parse-cache.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot-parse-cache.contract.d.ts","sourceRoot":"","sources":["../../contracts/bot-parse-cache/bot-parse-cache.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;;;;;;EAKM,CAAC;AAEjD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;IAUM,CAAC;AAErD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;EAMM,CAAC;AAElD,eAAO,MAAM,kCAAkC;;;;;;EAIM,CAAC;AAEtD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BjC,CAAC"}

package/dist/bot-parse-cache/bot-parse-cache.contract.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.botParseCacheContract = exports.BotParseCachePersistResponseSchema = exports.BotParseCachePersistBodySchema = exports.BotParseCacheLookupResponseSchema = exports.BotParseCacheLookupBodySchema = void 0;
+const core_1 = require("@ts-rest/core");
+const zod_1 = require("zod");
+const error_schemas_1 = require("../common/error-schemas");
+const c = (0, core_1.initContract)();
+exports.BotParseCacheLookupBodySchema = zod_1.z
+    .object({
+    rawText: zod_1.z.string().min(1),
+    parserVersion: zod_1.z.string().min(1),
+})
+    .openapi({ title: 'BotParseCacheLookupBody' });
+exports.BotParseCacheLookupResponseSchema = zod_1.z
+    .discriminatedUnion('hit', [
+    zod_1.z.object({
+        hit: zod_1.z.literal(true),
+        layer: zod_1.z.enum(['L1', 'L2']),
+        parsedJob: zod_1.z.array(zod_1.z.unknown()),
+        sim: zod_1.z.number().nullable(),
+    }),
+    zod_1.z.object({ hit: zod_1.z.literal(false) }),
+])
+    .openapi({ title: 'BotParseCacheLookupResponse' });
+exports.BotParseCachePersistBodySchema = zod_1.z
+    .object({
+    rawText: zod_1.z.string().min(1),
+    parsedJob: zod_1.z.array(zod_1.z.unknown()),
+    parserVersion: zod_1.z.string().min(1),
+})
+    .openapi({ title: 'BotParseCachePersistBody' });
+exports.BotParseCachePersistResponseSchema = zod_1.z
+    .object({
+    written: zod_1.z.boolean(),
+})
+    .openapi({ title: 'BotParseCachePersistResponse' });
+exports.botParseCacheContract = c.router({
+    lookup: {
+        method: 'POST',
+        path: '/bot-parse-cache/lookup',
+        body: exports.BotParseCacheLookupBodySchema,
+        responses: {
+            200: exports.BotParseCacheLookupResponseSchema,
+        },
+        summary: 'Look up cached parsed job by raw text (exact + fuzzy)',
+        metadata: { tags: ['BotParseCache'] },
+    },
+    persist: {
+        method: 'POST',
+        path: '/bot-parse-cache/persist',
+        body: exports.BotParseCachePersistBodySchema,
+        responses: {
+            200: exports.BotParseCachePersistResponseSchema,
+        },
+        summary: 'Persist a parsed job for future cache reuse',
+        metadata: { tags: ['BotParseCache'] },
+    },
+}, {
+    pathPrefix: '/v2',
+    commonResponses: {
+        400: error_schemas_1.ErrorResponseSchema,
+        500: error_schemas_1.ErrorResponseSchema,
+    },
+});