@lucaapp/service-utils 4.10.0 → 4.12.0

package/dist/index.d.ts

@@ -16,4 +16,6 @@ export * from './lib/random';
 export * from './lib/crypto';
 export * from './lib/phone';
 export * from './lib/http';
+export * from './lib/jobs';
+export * from './lib/validation';
 export * from './types';

package/dist/index.js

@@ -32,4 +32,6 @@ __exportStar(require("./lib/random"), exports);
 __exportStar(require("./lib/crypto"), exports);
 __exportStar(require("./lib/phone"), exports);
 __exportStar(require("./lib/http"), exports);
+__exportStar(require("./lib/jobs"), exports);
+__exportStar(require("./lib/validation"), exports);
 __exportStar(require("./types"), exports);

package/dist/lib/jobs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './jobTracker';
+export * from './schemas';

package/dist/lib/jobs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jobTracker"), exports);
+__exportStar(require("./schemas"), exports);

package/dist/lib/jobs/jobTracker.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from 'pino';
+import { JsonSchema } from './schemas';
+export interface JobStatus {
+    jobId: string;
+    jobName: string;
+    method: string;
+    status: 'running' | 'completed' | 'failed';
+    result?: JsonSchema;
+    error?: string;
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+}
+export interface RedisClient {
+    setex(key: string | Buffer, seconds: number, value: string | Buffer): Promise<string | void>;
+    get(key: string | Buffer): Promise<string | null>;
+    scan(cursor: number, command: string, pattern: string, countCommand: string, count: number): Promise<[string, string[]]>;
+}
+export declare const createJobTracker: (logger: Logger, redis: RedisClient) => {
+    createJobExecution: (jobName: string, method: string) => Promise<string>;
+    updateJobStatus: (jobId: string, result: JsonSchema, error?: Error) => Promise<void>;
+    getJobStatus: (jobId: string) => Promise<JobStatus | null>;
+    getAllRunningJobs: () => Promise<JobStatus[]>;
+    getLatestCompletions: () => Promise<Record<string, {
+        completedAt: string;
+        status: "completed" | "failed";
+        error?: string;
+    }>>;
+};
+export type JobTracker = ReturnType<typeof createJobTracker>;

package/dist/lib/jobs/jobTracker.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJobTracker = void 0;
+const uuid_1 = require("uuid");
+const JOB_STATUS_PREFIX = 'job:status:';
+const JOB_TTL = 24 * 60 * 60;
+const createJobTracker = (logger, redis) => {
+    const createJobExecution = async (jobName, method) => {
+        const jobId = (0, uuid_1.v4)();
+        const jobStatus = {
+            jobId,
+            jobName,
+            method,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        await redis.setex(key, JOB_TTL, JSON.stringify(jobStatus));
+        logger.info(`Created job execution: ${jobId} for job: ${jobName}, method: ${method}`);
+        return jobId;
+    };
+    const updateJobStatus = async (jobId, result, error) => {
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        const data = await redis.get(key);
+        if (!data) {
+            logger.warn(`Job status not found for jobId: ${jobId}`);
+            return;
+        }
+        const jobStatus = JSON.parse(data);
+        const completedAt = new Date();
+        const startedAt = new Date(jobStatus.startedAt);
+        const duration = completedAt.getTime() - startedAt.getTime();
+        if (error) {
+            jobStatus.status = 'failed';
+            jobStatus.error = error.message;
+        }
+        else {
+            jobStatus.status = 'completed';
+            jobStatus.result = result;
+        }
+        jobStatus.completedAt = completedAt.toISOString();
+        jobStatus.duration = duration;
+        await redis.setex(key, JOB_TTL, JSON.stringify(jobStatus));
+        logger.info(`Updated job status: ${jobId} - status: ${jobStatus.status}, duration: ${duration}ms`);
+    };
+    const getJobStatus = async (jobId) => {
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        const data = await redis.get(key);
+        if (!data) {
+            logger.warn(`Job status not found for jobId: ${jobId}`);
+            return null;
+        }
+        return JSON.parse(data);
+    };
+    const getAllRunningJobs = async () => {
+        const pattern = `${JOB_STATUS_PREFIX}*`;
+        const allJobs = [];
+        let cursor = 0;
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                const data = await redis.get(key);
+                if (data) {
+                    const jobStatus = JSON.parse(data);
+                    if (jobStatus.status === 'running') {
+                        allJobs.push(jobStatus);
+                    }
+                }
+            }
+        } while (cursor !== 0);
+        logger.info(`Found ${allJobs.length} running jobs`);
+        return allJobs;
+    };
+    const getLatestCompletions = async () => {
+        const pattern = `${JOB_STATUS_PREFIX}*`;
+        const completions = new Map();
+        let cursor = 0;
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                const data = await redis.get(key);
+                if (data) {
+                    const jobStatus = JSON.parse(data);
+                    if (jobStatus.completedAt &&
+                        (jobStatus.status === 'completed' || jobStatus.status === 'failed')) {
+                        const jobKey = `${jobStatus.jobName}/${jobStatus.method}`;
+                        const existing = completions.get(jobKey);
+                        if (!existing ||
+                            new Date(jobStatus.completedAt) > new Date(existing.completedAt)) {
+                            completions.set(jobKey, {
+                                completedAt: jobStatus.completedAt,
+                                status: jobStatus.status,
+                                error: jobStatus.error,
+                            });
+                        }
+                    }
+                }
+            }
+        } while (cursor !== 0);
+        logger.info(`Found ${completions.size} job completions`);
+        return Object.fromEntries(completions);
+    };
+    return {
+        createJobExecution,
+        updateJobStatus,
+        getJobStatus,
+        getAllRunningJobs,
+        getLatestCompletions,
+    };
+};
+exports.createJobTracker = createJobTracker;

package/dist/lib/jobs/schemas.d.ts

@@ -0,0 +1,258 @@
+import { z } from 'zod';
+/**
+ * Schema for job execution parameters
+ */
+export declare const parametersSchema: z.ZodObject<{
+    job: z.ZodString;
+    method: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    method: string;
+    job: string;
+}, {
+    method: string;
+    job: string;
+}>;
+/**
+ * Schema for job ID parameters
+ */
+export declare const jobIdParametersSchema: z.ZodObject<{
+    jobId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    jobId: string;
+}, {
+    jobId: string;
+}>;
+/**
+ * Schema for JSON request/response bodies
+ * Allows any object structure to pass through
+ */
+export declare const jsonSchema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+export type JsonSchema = z.infer<typeof jsonSchema>;
+/**
+ * Schema for running job information
+ */
+export declare const runningJobSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    jobName: z.ZodString;
+    method: z.ZodString;
+    status: z.ZodEnum<["running", "completed", "failed"]>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "running" | "completed" | "failed";
+    method: string;
+    jobId: string;
+    jobName: string;
+    startedAt: string;
+    completedAt?: string | undefined;
+    duration?: number | undefined;
+    error?: string | undefined;
+}, {
+    status: "running" | "completed" | "failed";
+    method: string;
+    jobId: string;
+    jobName: string;
+    startedAt: string;
+    completedAt?: string | undefined;
+    duration?: number | undefined;
+    error?: string | undefined;
+}>;
+/**
+ * Schema for job completion information
+ */
+export declare const jobCompletionSchema: z.ZodObject<{
+    completedAt: z.ZodString;
+    status: z.ZodEnum<["completed", "failed"]>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "completed" | "failed";
+    completedAt: string;
+    error?: string | undefined;
+}, {
+    status: "completed" | "failed";
+    completedAt: string;
+    error?: string | undefined;
+}>;
+/**
+ * Schema for job metadata (path and methods)
+ */
+export declare const jobMetadataSchema: z.ZodObject<{
+    path: z.ZodString;
+    methods: z.ZodArray<z.ZodString, "many">;
+    lastExecution: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        duration: z.ZodNumber;
+        error: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        error: string | null;
+        startedAt: string;
+        completedAt: string;
+        duration: number;
+    }, {
+        error: string | null;
+        startedAt: string;
+        completedAt: string;
+        duration: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    methods: string[];
+    lastExecution?: {
+        error: string | null;
+        startedAt: string;
+        completedAt: string;
+        duration: number;
+    } | null | undefined;
+}, {
+    path: string;
+    methods: string[];
+    lastExecution?: {
+        error: string | null;
+        startedAt: string;
+        completedAt: string;
+        duration: number;
+    } | null | undefined;
+}>;
+/**
+ * Schema for the complete jobs response
+ */
+export declare const jobsSchema: z.ZodObject<{
+    jobs: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodArray<z.ZodString, "many">;
+        lastExecution: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            startedAt: z.ZodString;
+            completedAt: z.ZodString;
+            duration: z.ZodNumber;
+            error: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        }, {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        methods: string[];
+        lastExecution?: {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        } | null | undefined;
+    }, {
+        path: string;
+        methods: string[];
+        lastExecution?: {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        } | null | undefined;
+    }>, "many">;
+    runningJobs: z.ZodArray<z.ZodObject<{
+        jobId: z.ZodString;
+        jobName: z.ZodString;
+        method: z.ZodString;
+        status: z.ZodEnum<["running", "completed", "failed"]>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "running" | "completed" | "failed";
+        method: string;
+        jobId: string;
+        jobName: string;
+        startedAt: string;
+        completedAt?: string | undefined;
+        duration?: number | undefined;
+        error?: string | undefined;
+    }, {
+        status: "running" | "completed" | "failed";
+        method: string;
+        jobId: string;
+        jobName: string;
+        startedAt: string;
+        completedAt?: string | undefined;
+        duration?: number | undefined;
+        error?: string | undefined;
+    }>, "many">;
+    jobCompletions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        completedAt: z.ZodString;
+        status: z.ZodEnum<["completed", "failed"]>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "completed" | "failed";
+        completedAt: string;
+        error?: string | undefined;
+    }, {
+        status: "completed" | "failed";
+        completedAt: string;
+        error?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    jobs: {
+        path: string;
+        methods: string[];
+        lastExecution?: {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        } | null | undefined;
+    }[];
+    runningJobs: {
+        status: "running" | "completed" | "failed";
+        method: string;
+        jobId: string;
+        jobName: string;
+        startedAt: string;
+        completedAt?: string | undefined;
+        duration?: number | undefined;
+        error?: string | undefined;
+    }[];
+    jobCompletions: Record<string, {
+        status: "completed" | "failed";
+        completedAt: string;
+        error?: string | undefined;
+    }>;
+}, {
+    jobs: {
+        path: string;
+        methods: string[];
+        lastExecution?: {
+            error: string | null;
+            startedAt: string;
+            completedAt: string;
+            duration: number;
+        } | null | undefined;
+    }[];
+    runningJobs: {
+        status: "running" | "completed" | "failed";
+        method: string;
+        jobId: string;
+        jobName: string;
+        startedAt: string;
+        completedAt?: string | undefined;
+        duration?: number | undefined;
+        error?: string | undefined;
+    }[];
+    jobCompletions: Record<string, {
+        status: "completed" | "failed";
+        completedAt: string;
+        error?: string | undefined;
+    }>;
+}>;
+export type JobsSchema = z.infer<typeof jobsSchema>;
+export type RunningJobSchema = z.infer<typeof runningJobSchema>;
+export type JobCompletionSchema = z.infer<typeof jobCompletionSchema>;
+export type JobMetadataSchema = z.infer<typeof jobMetadataSchema>;

package/dist/lib/jobs/schemas.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobsSchema = exports.jobMetadataSchema = exports.jobCompletionSchema = exports.runningJobSchema = exports.jsonSchema = exports.jobIdParametersSchema = exports.parametersSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for job execution parameters
+ */
+exports.parametersSchema = zod_1.z.object({
+    job: zod_1.z.string(),
+    method: zod_1.z.string(),
+});
+/**
+ * Schema for job ID parameters
+ */
+exports.jobIdParametersSchema = zod_1.z.object({
+    jobId: zod_1.z.string(),
+});
+/**
+ * Schema for JSON request/response bodies
+ * Allows any object structure to pass through
+ */
+exports.jsonSchema = zod_1.z.object({}).passthrough();
+/**
+ * Schema for running job information
+ */
+exports.runningJobSchema = zod_1.z.object({
+    jobId: zod_1.z.string(),
+    jobName: zod_1.z.string(),
+    method: zod_1.z.string(),
+    status: zod_1.z.enum(['running', 'completed', 'failed']),
+    startedAt: zod_1.z.string(),
+    completedAt: zod_1.z.string().optional(),
+    duration: zod_1.z.number().optional(),
+    error: zod_1.z.string().optional(),
+});
+/**
+ * Schema for job completion information
+ */
+exports.jobCompletionSchema = zod_1.z.object({
+    completedAt: zod_1.z.string(),
+    status: zod_1.z.enum(['completed', 'failed']),
+    error: zod_1.z.string().optional(),
+});
+/**
+ * Schema for job metadata (path and methods)
+ */
+exports.jobMetadataSchema = zod_1.z.object({
+    path: zod_1.z.string(),
+    methods: zod_1.z.array(zod_1.z.string()),
+    lastExecution: zod_1.z
+        .object({
+        startedAt: zod_1.z.string(),
+        completedAt: zod_1.z.string(),
+        duration: zod_1.z.number(),
+        error: zod_1.z.string().nullable(),
+    })
+        .nullable()
+        .optional(),
+});
+/**
+ * Schema for the complete jobs response
+ */
+exports.jobsSchema = zod_1.z.object({
+    jobs: zod_1.z.array(exports.jobMetadataSchema),
+    runningJobs: zod_1.z.array(exports.runningJobSchema),
+    jobCompletions: zod_1.z.record(exports.jobCompletionSchema),
+});

package/dist/lib/serviceIdentity/serviceIdentity.js

@@ -34,6 +34,7 @@ const api_1 = require("../api");
 const moment_1 = __importDefault(require("moment"));
 const requestTracer_1 = require("../requestTracer");
 const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
 const zod_1 = require("zod");
 const validator_1 = __importDefault(require("validator"));
 const JWT_ALGORITHM = 'ES256';
@@ -188,6 +189,17 @@ class ServiceIdentity {
         this.identityPrivateKey = identityPrivateKey;
         this.identityPublicKey = identityPublicKey;
         this.axiosClient = axios_1.default.create({ proxy: false });
+        // Configure axios-retry to handle 429 and respect Retry-After header
+        (0, axios_retry_1.default)(this.axiosClient, {
+            retries: 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+            shouldResetTimeout: true,
+            retryCondition: (error) => {
+                // Retry on network errors, 5xx errors, and 429 (rate limit)
+                return (axios_retry_1.default.isNetworkOrIdempotentRequestError(error) ||
+                    error.response?.status === 429);
+            },
+        });
         if (!debug) {
             this.axiosClient.interceptors.response.use(response => response, error => {
                 if (Array.isArray(error?.config?.headers) &&