@lucaapp/service-utils 5.22.0 → 5.23.1

package/dist/lib/http/axios.d.ts

@@ -30,8 +30,8 @@ export declare const handleAxiosError: (axiosError: AxiosError, logger: AxiosLog
  * @returns Object containing request and response interceptors
  */
 export declare const createLoggingInterceptors: (name: string, logger: AxiosLogger) => {
-    request: Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>["use"]>;
-    response: Parameters<AxiosInterceptorManager<AxiosResponse>["use"]>;
+    request: Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>['use']>;
+    response: Parameters<AxiosInterceptorManager<AxiosResponse>['use']>;
 };
 /**
  * Create a configured axios client with optional logging

package/dist/lib/iso3166/iso3166Mapping.d.ts

@@ -198,7 +198,7 @@ export type LanguageCode = keyof typeof ENGLISH_LANGUAGE_NAMES;
  * getLanguageName('fr') // returns 'French'
  * ```
  */
-export declare const getLanguageName: (lang: LanguageCode) => (typeof ENGLISH_LANGUAGE_NAMES)[LanguageCode];
+export declare const getLanguageName: (lang: LanguageCode) => typeof ENGLISH_LANGUAGE_NAMES[LanguageCode];
 /**
  * Comprehensive mapping of language codes to their native names
  * Includes currently supported languages and potential future additions

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

@@ -23,7 +23,7 @@ export declare const createJobTracker: (logger: Logger, redis: RedisClient) => {
     getAllRunningJobs: () => Promise<JobStatus[]>;
     getLatestCompletions: () => Promise<Record<string, {
         completedAt: string;
-        status: "completed" | "failed";
+        status: 'completed' | 'failed';
         error?: string;
     }>>;
 };

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

@@ -6,11 +6,11 @@ export declare const parametersSchema: z.ZodObject<{
     job: z.ZodString;
     method: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    method: string;
     job: string;
-}, {
     method: string;
+}, {
     job: string;
+    method: string;
 }>;
 /**
  * Schema for job ID parameters
@@ -41,23 +41,23 @@ export declare const runningJobSchema: z.ZodObject<{
     duration: z.ZodOptional<z.ZodNumber>;
     error: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    status: "running" | "completed" | "failed";
-    method: string;
     jobId: string;
     jobName: string;
+    method: string;
+    status: "completed" | "failed" | "running";
     startedAt: string;
-    error?: string | undefined;
     completedAt?: string | undefined;
     duration?: number | undefined;
+    error?: string | undefined;
 }, {
-    status: "running" | "completed" | "failed";
-    method: string;
     jobId: string;
     jobName: string;
+    method: string;
+    status: "completed" | "failed" | "running";
     startedAt: string;
-    error?: string | undefined;
     completedAt?: string | undefined;
     duration?: number | undefined;
+    error?: string | undefined;
 }>;
 /**
  * Schema for job completion information
@@ -67,12 +67,12 @@ export declare const jobCompletionSchema: z.ZodObject<{
     status: z.ZodEnum<["completed", "failed"]>;
     error: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    status: "completed" | "failed";
     completedAt: string;
+    status: "completed" | "failed";
     error?: string | undefined;
 }, {
-    status: "completed" | "failed";
     completedAt: string;
+    status: "completed" | "failed";
     error?: string | undefined;
 }>;
 /**
@@ -87,33 +87,33 @@ export declare const jobMetadataSchema: z.ZodObject<{
         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;
+        error: string | null;
     }>>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     methods: string[];
     lastExecution?: {
-        error: string | null;
         startedAt: string;
         completedAt: string;
         duration: number;
+        error: string | null;
     } | null | undefined;
 }, {
     path: string;
     methods: string[];
     lastExecution?: {
-        error: string | null;
         startedAt: string;
         completedAt: string;
         duration: number;
+        error: string | null;
     } | null | undefined;
 }>;
 /**
@@ -129,33 +129,33 @@ export declare const jobsSchema: z.ZodObject<{
             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;
+            error: string | null;
         }>>>;
     }, "strip", z.ZodTypeAny, {
         path: string;
         methods: string[];
         lastExecution?: {
-            error: string | null;
             startedAt: string;
             completedAt: string;
             duration: number;
+            error: string | null;
         } | null | undefined;
     }, {
         path: string;
         methods: string[];
         lastExecution?: {
-            error: string | null;
             startedAt: string;
             completedAt: string;
             duration: number;
+            error: string | null;
         } | null | undefined;
     }>, "many">;
     runningJobs: z.ZodArray<z.ZodObject<{
@@ -168,35 +168,35 @@ export declare const jobsSchema: z.ZodObject<{
         duration: z.ZodOptional<z.ZodNumber>;
         error: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        status: "running" | "completed" | "failed";
-        method: string;
         jobId: string;
         jobName: string;
+        method: string;
+        status: "completed" | "failed" | "running";
         startedAt: string;
-        error?: string | undefined;
         completedAt?: string | undefined;
         duration?: number | undefined;
+        error?: string | undefined;
     }, {
-        status: "running" | "completed" | "failed";
-        method: string;
         jobId: string;
         jobName: string;
+        method: string;
+        status: "completed" | "failed" | "running";
         startedAt: string;
-        error?: string | undefined;
         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;
+        status: "completed" | "failed";
         error?: string | undefined;
     }, {
-        status: "completed" | "failed";
         completedAt: string;
+        status: "completed" | "failed";
         error?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -204,25 +204,25 @@ export declare const jobsSchema: z.ZodObject<{
         path: string;
         methods: string[];
         lastExecution?: {
-            error: string | null;
             startedAt: string;
             completedAt: string;
             duration: number;
+            error: string | null;
         } | null | undefined;
     }[];
     runningJobs: {
-        status: "running" | "completed" | "failed";
-        method: string;
         jobId: string;
         jobName: string;
+        method: string;
+        status: "completed" | "failed" | "running";
         startedAt: string;
-        error?: string | undefined;
         completedAt?: string | undefined;
         duration?: number | undefined;
+        error?: string | undefined;
     }[];
     jobCompletions: Record<string, {
-        status: "completed" | "failed";
         completedAt: string;
+        status: "completed" | "failed";
         error?: string | undefined;
     }>;
 }, {
@@ -230,25 +230,25 @@ export declare const jobsSchema: z.ZodObject<{
         path: string;
         methods: string[];
         lastExecution?: {
-            error: string | null;
             startedAt: string;
             completedAt: string;
             duration: number;
+            error: string | null;
         } | null | undefined;
     }[];
     runningJobs: {
-        status: "running" | "completed" | "failed";
-        method: string;
         jobId: string;
         jobName: string;
+        method: string;
+        status: "completed" | "failed" | "running";
         startedAt: string;
-        error?: string | undefined;
         completedAt?: string | undefined;
         duration?: number | undefined;
+        error?: string | undefined;
     }[];
     jobCompletions: Record<string, {
-        status: "completed" | "failed";
         completedAt: string;
+        status: "completed" | "failed";
         error?: string | undefined;
     }>;
 }>;

package/dist/lib/kafka/metrics.d.ts

@@ -1,8 +1,8 @@
 import { metricsClient } from '../metrics';
 declare const messageProducedSizeCounter: metricsClient.Histogram<"topic">;
 declare const messageProduceError: metricsClient.Counter<"topic">;
-declare const messageConsumedCounter: metricsClient.Counter<"topic" | "groupId">;
-declare const messageConsumedErrorCounter: metricsClient.Counter<"topic" | "groupId">;
-declare const messageAcknowledgedCounter: metricsClient.Counter<"topic" | "groupId">;
-declare const messageSkippedForeignEnvCounter: metricsClient.Counter<"topic" | "groupId">;
+declare const messageConsumedCounter: metricsClient.Counter<"groupId" | "topic">;
+declare const messageConsumedErrorCounter: metricsClient.Counter<"groupId" | "topic">;
+declare const messageAcknowledgedCounter: metricsClient.Counter<"groupId" | "topic">;
+declare const messageSkippedForeignEnvCounter: metricsClient.Counter<"groupId" | "topic">;
 export { messageProducedSizeCounter, messageProduceError, messageConsumedCounter, messageConsumedErrorCounter, messageAcknowledgedCounter, messageSkippedForeignEnvCounter, };

package/dist/lib/pgBoss/controller/routes.schema.d.ts

@@ -10,11 +10,11 @@ export declare const queueJobParamsSchema: z.ZodObject<{
     queue: z.ZodString;
     id: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
     queue: string;
-}, {
     id: string;
+}, {
     queue: string;
+    id: string;
 }>;
 export declare const scheduleNameParamsSchema: z.ZodObject<{
     name: z.ZodString;
@@ -59,21 +59,21 @@ export declare const enqueueBodySchema: z.ZodObject<{
         singletonSeconds?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    data?: Record<string, unknown> | undefined;
     options?: {
         priority?: number | undefined;
         startAfter?: string | number | Date | undefined;
         singletonKey?: string | undefined;
         singletonSeconds?: number | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }, {
+    data?: Record<string, unknown> | undefined;
     options?: {
         priority?: number | undefined;
         startAfter?: string | number | Date | undefined;
         singletonKey?: string | undefined;
         singletonSeconds?: number | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }>;
 export declare const scheduleBodySchema: z.ZodObject<{
     name: z.ZodString;
@@ -89,17 +89,17 @@ export declare const scheduleBodySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     cron: string;
+    data?: Record<string, unknown> | undefined;
     options?: {
         tz?: string | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }, {
     name: string;
     cron: string;
+    data?: Record<string, unknown> | undefined;
     options?: {
         tz?: string | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }>;
 export declare const updateScheduleBodySchema: z.ZodObject<{
     cron: z.ZodString;
@@ -113,16 +113,16 @@ export declare const updateScheduleBodySchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     cron: string;
+    data?: Record<string, unknown> | undefined;
     options?: {
         tz?: string | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }, {
     cron: string;
+    data?: Record<string, unknown> | undefined;
     options?: {
         tz?: string | undefined;
     } | undefined;
-    data?: Record<string, unknown> | undefined;
 }>;
 export declare const queueStatsSchema: z.ZodObject<{
     name: z.ZodString;
@@ -137,26 +137,26 @@ export declare const queueStatsSchema: z.ZodObject<{
     totalCount: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    queuedCount: number;
-    activeCount: number;
-    totalCount: number;
-    retryDelay?: number | undefined;
     policy?: string | undefined;
     retryLimit?: number | undefined;
+    retryDelay?: number | undefined;
     retryBackoff?: boolean | undefined;
     expireInSeconds?: number | undefined;
     deadLetter?: string | null | undefined;
-}, {
-    name: string;
     queuedCount: number;
     activeCount: number;
     totalCount: number;
-    retryDelay?: number | undefined;
+}, {
+    name: string;
     policy?: string | undefined;
     retryLimit?: number | undefined;
+    retryDelay?: number | undefined;
     retryBackoff?: boolean | undefined;
     expireInSeconds?: number | undefined;
     deadLetter?: string | null | undefined;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
 }>;
 export declare const queueStatsArraySchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
@@ -171,26 +171,26 @@ export declare const queueStatsArraySchema: z.ZodArray<z.ZodObject<{
     totalCount: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    queuedCount: number;
-    activeCount: number;
-    totalCount: number;
-    retryDelay?: number | undefined;
     policy?: string | undefined;
     retryLimit?: number | undefined;
+    retryDelay?: number | undefined;
     retryBackoff?: boolean | undefined;
     expireInSeconds?: number | undefined;
     deadLetter?: string | null | undefined;
-}, {
-    name: string;
     queuedCount: number;
     activeCount: number;
     totalCount: number;
-    retryDelay?: number | undefined;
+}, {
+    name: string;
     policy?: string | undefined;
     retryLimit?: number | undefined;
+    retryDelay?: number | undefined;
     retryBackoff?: boolean | undefined;
     expireInSeconds?: number | undefined;
     deadLetter?: string | null | undefined;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
 }>, "many">;
 export declare const jobDetailSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export declare const jobArraySchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
@@ -205,12 +205,12 @@ export declare const successResponseSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     success: boolean;
-    name?: string | undefined;
-    deleted?: string | undefined;
     jobId?: string | undefined;
+    deleted?: string | undefined;
+    name?: string | undefined;
 }, {
     success: boolean;
-    name?: string | undefined;
-    deleted?: string | undefined;
     jobId?: string | undefined;
+    deleted?: string | undefined;
+    name?: string | undefined;
 }>;

package/dist/lib/pgBoss/service/manageJob.d.ts

@@ -1,3 +1,3 @@
 import { PgBoss } from 'pg-boss';
 import type { Logger } from 'pino';
-export declare const manageJob: (boss: PgBoss, logger: Logger, action: "retry" | "cancel" | "delete", queueName: string, jobId: string) => Promise<void>;
+export declare const manageJob: (boss: PgBoss, logger: Logger, action: 'retry' | 'cancel' | 'delete', queueName: string, jobId: string) => Promise<void>;

package/dist/lib/serviceIdentity/serviceIdentity.d.ts

@@ -64,11 +64,11 @@ declare class ServiceIdentity {
         payload: z.ZodAny;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">, z.ZodUndefined]>>>;
     }, "strip", z.ZodTypeAny, {
-        params?: Record<string, string | number | (string | number)[] | undefined> | undefined;
         payload?: any;
-    }, {
         params?: Record<string, string | number | (string | number)[] | undefined> | undefined;
+    }, {
         payload?: any;
+        params?: Record<string, string | number | (string | number)[] | undefined> | undefined;
     }>>;
     identityJWKSRoute: RequestHandler;
 }

package/dist/lib/sessionRevocation/sessionRevocation.d.ts

@@ -1,7 +1,8 @@
-import { IsOperatorTokenRevokedParams, IsRevokedOperatorJwtParams, RevokeOperatorTokensParams } from './types';
+import { CheckRevocationRedisSafetyParams, IsOperatorTokenRevokedParams, IsRevokedOperatorJwtParams, RevokeOperatorTokensParams } from './types';
 export declare const OPERATOR_REVOCATION_KEY_PREFIX = "revoked:operator:";
 export declare const OPERATOR_REVOCATION_TTL_SECONDS: number;
 export declare const buildOperatorRevocationKey: (operatorUuid: string) => string;
 export declare const revokeOperatorTokens: ({ redis, logger, operatorUuid, }: RevokeOperatorTokensParams) => Promise<void>;
 export declare const isOperatorTokenRevoked: ({ redis, logger, operatorUuid, issuedAtSeconds, }: IsOperatorTokenRevokedParams) => Promise<boolean>;
 export declare const isRevokedOperatorJwt: ({ redis, logger, payload, operatorRole, }: IsRevokedOperatorJwtParams) => Promise<boolean>;
+export declare const checkRevocationRedisSafety: ({ redis, logger, }: CheckRevocationRedisSafetyParams) => Promise<void>;

package/dist/lib/sessionRevocation/sessionRevocation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRevokedOperatorJwt = exports.isOperatorTokenRevoked = exports.revokeOperatorTokens = exports.buildOperatorRevocationKey = exports.OPERATOR_REVOCATION_TTL_SECONDS = exports.OPERATOR_REVOCATION_KEY_PREFIX = void 0;
+exports.checkRevocationRedisSafety = exports.isRevokedOperatorJwt = exports.isOperatorTokenRevoked = exports.revokeOperatorTokens = exports.buildOperatorRevocationKey = exports.OPERATOR_REVOCATION_TTL_SECONDS = exports.OPERATOR_REVOCATION_KEY_PREFIX = void 0;
 exports.OPERATOR_REVOCATION_KEY_PREFIX = 'revoked:operator:';
 exports.OPERATOR_REVOCATION_TTL_SECONDS = 24 * 60 * 60;
 const REDIS_GET_TIMEOUT_MS = 50;
@@ -68,3 +68,25 @@ const isRevokedOperatorJwt = async ({ redis, logger, payload, operatorRole, }) =
     });
 };
 exports.isRevokedOperatorJwt = isRevokedOperatorJwt;
+const readMaxMemoryPolicy = (raw) => {
+    if (Array.isArray(raw) && raw.length >= 2 && typeof raw[1] === 'string') {
+        return raw[1];
+    }
+    return null;
+};
+const checkRevocationRedisSafety = async ({ redis, logger, }) => {
+    try {
+        const policy = readMaxMemoryPolicy(await redis.config('GET', 'maxmemory-policy'));
+        if (policy === null) {
+            logger.warn('could not read operator token revocation redis maxmemory-policy');
+            return;
+        }
+        if (policy !== 'noeviction') {
+            logger.error({ policy }, 'operator token revocation redis uses evicting maxmemory-policy');
+        }
+    }
+    catch (error) {
+        logger.warn(error, 'operator token revocation redis maxmemory-policy check unavailable');
+    }
+};
+exports.checkRevocationRedisSafety = checkRevocationRedisSafety;

package/dist/lib/sessionRevocation/types.d.ts

@@ -25,3 +25,10 @@ export interface IsRevokedOperatorJwtParams {
     payload: RevocableJwtPayload;
     operatorRole: string;
 }
+export interface MaxMemoryPolicyReader {
+    config(subcommand: 'GET', parameter: string): Promise<unknown>;
+}
+export interface CheckRevocationRedisSafetyParams {
+    redis: MaxMemoryPolicyReader;
+    logger: Pick<Logger, 'warn' | 'error'>;
+}

package/dist/lib/validation.d.ts

@@ -4,218 +4,8 @@ import { Money } from '../lib/money/money';
 export declare const preprocessArrayFromQueryString: (input: unknown) => unknown[] | undefined;
 export declare const preprocessNumberFromQueryString: (input: unknown) => number | unknown;
 export declare const preprocessBooleanFromQueryString: (input: unknown) => boolean | unknown;
-export declare const preprocessBooleanFromString: (input: unknown) => boolean | unknown;
+export declare const preprocessBooleanFromString: typeof preprocessBooleanFromQueryString;
 declare const z: {
-    string: () => ZodString;
-    safeString: () => ZodString;
-    safeText: () => ZodString;
-    safeBusinessStringForOnboarding: () => zod.ZodEffects<zod.ZodString, string, string>;
-    safeNameForOnboarding: () => zod.ZodEffects<zod.ZodString, string, string>;
-    nonemptyString: () => zod.ZodString;
-    alphaNumericString: () => zod.ZodString;
-    tableId: () => zod.ZodString;
-    uuid: () => ZodString;
-    uuidv4: () => zod.ZodEffects<zod.ZodString, string, string>;
-    email: () => ZodEffects<ZodString>;
-    phoneNumber: () => ZodEffects<ZodEffects<ZodString>>;
-    nullablePhoneNumber: () => zod.ZodEffects<zod.ZodEffects<zod.ZodString, string, string>, string | null, string>;
-    strongPassword: () => zod.ZodEffects<zod.ZodString, string, string>;
-    zipCode: (locale?: validator.PostalCodeLocale) => ZodEffects<ZodString, string>;
-    countryCode: () => zod.ZodString;
-    moneyDecimalString: (locale?: string) => zod.ZodEffects<zod.ZodString, string, string>;
-    moneyFromFloat: () => ZodEffects<ZodEffects<ZodNumber>, Money>;
-    moneyFromInt: () => ZodEffects<ZodNumber, Money>;
-    convertMoneyFieldsToCurrency: <T extends ZodObject<Record<string, ZodTypeAny>>>(schema: T) => ZodEffects<T>;
-    unixTimestamp: () => zod.ZodNumber;
-    integerString: (options?: {
-        maxLength?: number;
-        lt?: number;
-        gt?: number;
-        transform?: boolean;
-    }) => zod.ZodEffects<zod.ZodEffects<zod.ZodType<string, zod.ZodTypeDef, string>, string, string>, number, string>;
-    integerStringRaw: (options?: {
-        maxLength?: number;
-        lt?: number;
-        gt?: number;
-        transform?: boolean;
-    }) => typeof options.transform extends true ? ZodEffects<ZodType<number>> : ZodEffects<ZodType<string>>;
-    bigIntegerString: () => zod.ZodEffects<zod.ZodString, string, string>;
-    floatString: (options?: {
-        maxLength?: number;
-        lt: number;
-        gt: number;
-    }) => zod.ZodEffects<zod.ZodEffects<zod.ZodString, string, string>, number, string>;
-    hex: ({ min, max, length, rawLength, }?: {
-        min?: number;
-        max?: number;
-        length?: number;
-        rawLength?: number;
-    }) => zod.ZodEffects<zod.ZodString, string, string>;
-    sha256: () => zod.ZodEffects<zod.ZodString, string, string>;
-    base64: ({ min, max, length, rawLength, isBase64Url, }?: {
-        min?: number;
-        max?: number;
-        length?: number;
-        rawLength?: number;
-        isBase64Url?: boolean;
-    }) => ZodEffects<ZodString>;
-    bearerToken: () => ZodEffects<ZodEffects<ZodString>>;
-    jwt: ({ max }: {
-        max: number;
-    }) => ZodEffects<ZodString>;
-    ecPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
-    ecCompressedPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
-    uncompressedECPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
-    ecSignature: () => zod.ZodEffects<zod.ZodString, string, string>;
-    iv: () => zod.ZodEffects<zod.ZodString, string, string>;
-    mac: () => zod.ZodEffects<zod.ZodString, string, string>;
-    traceId: () => zod.ZodEffects<zod.ZodString, string, string>;
-    isoDateString: () => ZodEffects<ZodString, string>;
-    rfc3339String: () => ZodEffects<ZodString, string>;
-    iso8601Date: () => zod.ZodEffects<zod.ZodString, string, string>;
-    urlHttpsString: () => zod.ZodEffects<zod.ZodString, string, string>;
-    urlHttpOrHttpsString: () => zod.ZodEffects<zod.ZodString, string, string>;
-    language: () => ZodTypeAny;
-    dsgcPayload: () => zod.ZodObject<{
-        certificates: zod.ZodArray<zod.ZodObject<{
-            certificateType: zod.ZodString;
-            country: zod.ZodString;
-            kid: zod.ZodString;
-            rawData: zod.ZodString;
-            signature: zod.ZodString;
-            thumbprint: zod.ZodString;
-            timestamp: zod.ZodString;
-        }, "strip", zod.ZodTypeAny, {
-            timestamp: string;
-            kid: string;
-            signature: string;
-            certificateType: string;
-            country: string;
-            rawData: string;
-            thumbprint: string;
-        }, {
-            timestamp: string;
-            kid: string;
-            signature: string;
-            certificateType: string;
-            country: string;
-            rawData: string;
-            thumbprint: string;
-        }>, "many">;
-    }, "strip", zod.ZodTypeAny, {
-        certificates: {
-            timestamp: string;
-            kid: string;
-            signature: string;
-            certificateType: string;
-            country: string;
-            rawData: string;
-            thumbprint: string;
-        }[];
-    }, {
-        certificates: {
-            timestamp: string;
-            kid: string;
-            signature: string;
-            certificateType: string;
-            country: string;
-            rawData: string;
-            thumbprint: string;
-        }[];
-    }>;
-    dccListPayload: () => zod.ZodArray<zod.ZodObject<{
-        identifier: zod.ZodString;
-        version: zod.ZodString;
-        country: zod.ZodString;
-        hash: zod.ZodString;
-    }, "strip", zod.ZodTypeAny, {
-        version: string;
-        country: string;
-        identifier: string;
-        hash: string;
-    }, {
-        version: string;
-        country: string;
-        identifier: string;
-        hash: string;
-    }>, "many">;
-    dccRulePayload: () => zod.ZodObject<{
-        Identifier: zod.ZodString;
-        Type: zod.ZodString;
-        Country: zod.ZodString;
-        Version: zod.ZodString;
-        SchemaVersion: zod.ZodString;
-        Engine: zod.ZodString;
-        EngineVersion: zod.ZodString;
-        CertificateType: zod.ZodString;
-        Description: zod.ZodArray<zod.ZodObject<{
-            lang: zod.ZodString;
-            desc: zod.ZodString;
-        }, "strip", zod.ZodTypeAny, {
-            lang: string;
-            desc: string;
-        }, {
-            lang: string;
-            desc: string;
-        }>, "many">;
-        ValidFrom: zod.ZodString;
-        ValidTo: zod.ZodString;
-        AffectedFields: zod.ZodArray<zod.ZodString, "many">;
-        Logic: zod.ZodAny;
-    }, "strip", zod.ZodTypeAny, {
-        Identifier: string;
-        Type: string;
-        Country: string;
-        Version: string;
-        SchemaVersion: string;
-        Engine: string;
-        EngineVersion: string;
-        CertificateType: string;
-        Description: {
-            lang: string;
-            desc: string;
-        }[];
-        ValidFrom: string;
-        ValidTo: string;
-        AffectedFields: string[];
-        Logic?: any;
-    }, {
-        Identifier: string;
-        Type: string;
-        Country: string;
-        Version: string;
-        SchemaVersion: string;
-        Engine: string;
-        EngineVersion: string;
-        CertificateType: string;
-        Description: {
-            lang: string;
-            desc: string;
-        }[];
-        ValidFrom: string;
-        ValidTo: string;
-        AffectedFields: string[];
-        Logic?: any;
-    }>;
-    setErrorMap(map: zod.ZodErrorMap): void;
-    getErrorMap(): zod.ZodErrorMap;
-    defaultErrorMap: zod.ZodErrorMap;
-    addIssueToContext(ctx: zod.ParseContext, issueData: zod.IssueData): void;
-    makeIssue: (params: {
-        data: any;
-        path: (string | number)[];
-        errorMaps: zod.ZodErrorMap[];
-        issueData: zod.IssueData;
-    }) => zod.ZodIssue;
-    EMPTY_PATH: zod.ParsePath;
-    ParseStatus: typeof zod.ParseStatus;
-    INVALID: zod.INVALID;
-    DIRTY: <T>(value: T) => zod.DIRTY<T>;
-    OK: <T>(value: T) => zod.OK<T>;
-    isAborted: (x: zod.ParseReturnType<any>) => x is zod.INVALID;
-    isDirty: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
-    isValid: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T>;
-    isAsync: <T>(x: zod.ParseReturnType<T>) => x is zod.AsyncParseReturnType<T>;
     util: typeof zod.util;
     objectUtil: typeof zod.objectUtil;
     ZodParsedType: {
@@ -241,19 +31,53 @@ declare const z: {
         set: "set";
     };
     getParsedType: (data: any) => zod.ZodParsedType;
+    ZodIssueCode: {
+        invalid_type: "invalid_type";
+        invalid_literal: "invalid_literal";
+        custom: "custom";
+        invalid_union: "invalid_union";
+        invalid_union_discriminator: "invalid_union_discriminator";
+        invalid_enum_value: "invalid_enum_value";
+        unrecognized_keys: "unrecognized_keys";
+        invalid_arguments: "invalid_arguments";
+        invalid_return_type: "invalid_return_type";
+        invalid_date: "invalid_date";
+        invalid_string: "invalid_string";
+        too_small: "too_small";
+        too_big: "too_big";
+        invalid_intersection_types: "invalid_intersection_types";
+        not_multiple_of: "not_multiple_of";
+        not_finite: "not_finite";
+    };
+    quotelessJson: (obj: any) => string;
+    ZodError: typeof zod.ZodError;
+    defaultErrorMap: zod.ZodErrorMap;
+    setErrorMap(map: zod.ZodErrorMap): void;
+    getErrorMap(): zod.ZodErrorMap;
+    makeIssue: (params: {
+        data: any;
+        path: (string | number)[];
+        errorMaps: zod.ZodErrorMap[];
+        issueData: zod.IssueData;
+    }) => zod.ZodIssue;
+    EMPTY_PATH: zod.ParsePath;
+    addIssueToContext(ctx: zod.ParseContext, issueData: zod.IssueData): void;
+    ParseStatus: typeof zod.ParseStatus;
+    INVALID: zod.INVALID;
+    DIRTY: <T>(value: T) => zod.DIRTY<T>;
+    OK: <T>(value: T) => zod.OK<T>;
+    isAborted: (x: zod.ParseReturnType<any>) => x is zod.INVALID;
+    isDirty: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
+    isValid: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T>;
+    isAsync: <T>(x: zod.ParseReturnType<T>) => x is zod.AsyncParseReturnType<T>;
+    ZodType: typeof ZodType;
     datetimeRegex(args: {
         precision?: number | null;
         offset?: boolean;
         local?: boolean;
     }): RegExp;
-    custom<T>(check?: (data: any) => any, params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean;
-    }) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean;
-    }), fatal?: boolean): ZodType<T, zod.ZodTypeDef, T>;
-    ZodType: typeof zod.ZodType;
-    ZodString: typeof zod.ZodString;
-    ZodNumber: typeof zod.ZodNumber;
+    ZodString: typeof ZodString;
+    ZodNumber: typeof ZodNumber;
     ZodBigInt: typeof zod.ZodBigInt;
     ZodBoolean: typeof zod.ZodBoolean;
     ZodDate: typeof zod.ZodDate;
@@ -265,7 +89,7 @@ declare const z: {
     ZodNever: typeof zod.ZodNever;
     ZodVoid: typeof zod.ZodVoid;
     ZodArray: typeof zod.ZodArray;
-    ZodObject: typeof zod.ZodObject;
+    ZodObject: typeof ZodObject;
     ZodUnion: typeof zod.ZodUnion;
     ZodDiscriminatedUnion: typeof zod.ZodDiscriminatedUnion;
     ZodIntersection: typeof zod.ZodIntersection;
@@ -279,8 +103,8 @@ declare const z: {
     ZodEnum: typeof zod.ZodEnum;
     ZodNativeEnum: typeof zod.ZodNativeEnum;
     ZodPromise: typeof zod.ZodPromise;
-    ZodEffects: typeof zod.ZodEffects;
-    ZodTransformer: typeof zod.ZodEffects;
+    ZodEffects: typeof ZodEffects;
+    ZodTransformer: typeof ZodEffects;
     ZodOptional: typeof zod.ZodOptional;
     ZodNullable: typeof zod.ZodNullable;
     ZodDefault: typeof zod.ZodDefault;
@@ -290,8 +114,13 @@ declare const z: {
     ZodBranded: typeof zod.ZodBranded;
     ZodPipeline: typeof zod.ZodPipeline;
     ZodReadonly: typeof zod.ZodReadonly;
-    Schema: typeof zod.ZodType;
-    ZodSchema: typeof zod.ZodType;
+    custom<T>(check?: (data: any) => any, params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }), fatal?: boolean): ZodType<T, zod.ZodTypeDef, T>;
+    Schema: typeof ZodType;
+    ZodSchema: typeof ZodType;
     late: {
         object: <T extends zod.ZodRawShape>(shape: () => T, params?: zod.RawCreateParams) => ZodObject<T, "strip">;
     };
@@ -337,7 +166,7 @@ declare const z: {
     intersection: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: zod.RawCreateParams) => zod.ZodIntersection<T, U>;
     lazy: <T extends ZodTypeAny>(getter: () => T, params?: zod.RawCreateParams) => zod.ZodLazy<T>;
     literal: <T extends zod.Primitive>(value: T, params?: zod.RawCreateParams) => zod.ZodLiteral<T>;
-    map: <Key extends ZodTypeAny = zod.ZodTypeAny, Value extends ZodTypeAny = zod.ZodTypeAny>(keyType: Key, valueType: Value, params?: zod.RawCreateParams) => zod.ZodMap<Key, Value>;
+    map: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key, valueType: Value, params?: zod.RawCreateParams) => zod.ZodMap<Key, Value>;
     nan: (params?: zod.RawCreateParams) => zod.ZodNaN;
     nativeEnum: <T extends zod.EnumLike>(values: T, params?: zod.RawCreateParams) => zod.ZodNativeEnum<T>;
     never: (params?: zod.RawCreateParams) => zod.ZodNever;
@@ -355,7 +184,7 @@ declare const z: {
     preprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown, schema: I, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
     promise: <T extends ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodPromise<T>;
     record: typeof zod.ZodRecord.create;
-    set: <Value extends ZodTypeAny = zod.ZodTypeAny>(valueType: Value, params?: zod.RawCreateParams) => zod.ZodSet<Value>;
+    set: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value, params?: zod.RawCreateParams) => zod.ZodSet<Value>;
     strictObject: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => ZodObject<T, "strict">;
     symbol: (params?: zod.RawCreateParams) => zod.ZodSymbol;
     transformer: <I extends ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"]>;
@@ -365,26 +194,197 @@ declare const z: {
     unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
     void: (params?: zod.RawCreateParams) => zod.ZodVoid;
     NEVER: never;
-    ZodIssueCode: {
-        invalid_type: "invalid_type";
-        invalid_literal: "invalid_literal";
-        custom: "custom";
-        invalid_union: "invalid_union";
-        invalid_union_discriminator: "invalid_union_discriminator";
-        invalid_enum_value: "invalid_enum_value";
-        unrecognized_keys: "unrecognized_keys";
-        invalid_arguments: "invalid_arguments";
-        invalid_return_type: "invalid_return_type";
-        invalid_date: "invalid_date";
-        invalid_string: "invalid_string";
-        too_small: "too_small";
-        too_big: "too_big";
-        invalid_intersection_types: "invalid_intersection_types";
-        not_multiple_of: "not_multiple_of";
-        not_finite: "not_finite";
-    };
-    quotelessJson: (obj: any) => string;
-    ZodError: typeof zod.ZodError;
+    string: () => ZodString;
+    safeString: () => ZodString;
+    safeText: () => ZodString;
+    safeBusinessStringForOnboarding: () => ZodEffects<ZodString, string, string>;
+    safeNameForOnboarding: () => ZodEffects<ZodString, string, string>;
+    nonemptyString: () => ZodString;
+    alphaNumericString: () => ZodString;
+    tableId: () => ZodString;
+    uuid: () => ZodString;
+    uuidv4: () => ZodEffects<ZodString, string, string>;
+    email: () => ZodEffects<ZodString>;
+    phoneNumber: () => ZodEffects<ZodEffects<ZodString>>;
+    nullablePhoneNumber: () => ZodEffects<ZodEffects<ZodString, string, string>, string | null, string>;
+    strongPassword: () => ZodEffects<ZodString, string, string>;
+    zipCode: (locale?: validator.PostalCodeLocale) => ZodEffects<ZodString, string>;
+    countryCode: () => ZodString;
+    moneyDecimalString: (locale?: string) => ZodEffects<ZodString, string, string>;
+    moneyFromFloat: () => ZodEffects<ZodEffects<ZodNumber>, Money>;
+    moneyFromInt: () => ZodEffects<ZodNumber, Money>;
+    convertMoneyFieldsToCurrency: <T extends ZodObject<Record<string, ZodTypeAny>>>(schema: T) => ZodEffects<T>;
+    unixTimestamp: () => ZodNumber;
+    integerString: (options?: {
+        maxLength?: number;
+        lt?: number;
+        gt?: number;
+        transform?: boolean;
+    }) => ZodEffects<ZodEffects<ZodType<string, zod.ZodTypeDef, string>, string, string>, number, string>;
+    integerStringRaw: (options?: {
+        maxLength?: number;
+        lt?: number;
+        gt?: number;
+        transform?: boolean;
+    }) => typeof options.transform extends true ? ZodEffects<ZodType<number>> : ZodEffects<ZodType<string>>;
+    bigIntegerString: () => ZodEffects<ZodString, string, string>;
+    floatString: (options?: {
+        maxLength?: number;
+        lt: number;
+        gt: number;
+    }) => ZodEffects<ZodEffects<ZodString, string, string>, number, string>;
+    hex: ({ min, max, length, rawLength, }?: {
+        min?: number;
+        max?: number;
+        length?: number;
+        rawLength?: number;
+    }) => ZodEffects<ZodString, string, string>;
+    sha256: () => ZodEffects<ZodString, string, string>;
+    base64: ({ min, max, length, rawLength, isBase64Url, }?: {
+        min?: number;
+        max?: number;
+        length?: number;
+        rawLength?: number;
+        isBase64Url?: boolean;
+    }) => ZodEffects<ZodString>;
+    bearerToken: () => ZodEffects<ZodEffects<ZodString>>;
+    jwt: ({ max }: {
+        max: number;
+    }) => ZodEffects<ZodString>;
+    ecPublicKey: () => ZodEffects<ZodString, string, string>;
+    ecCompressedPublicKey: () => ZodEffects<ZodString, string, string>;
+    uncompressedECPublicKey: () => ZodEffects<ZodString, string, string>;
+    ecSignature: () => ZodEffects<ZodString, string, string>;
+    iv: () => ZodEffects<ZodString, string, string>;
+    mac: () => ZodEffects<ZodString, string, string>;
+    traceId: () => ZodEffects<ZodString, string, string>;
+    isoDateString: () => ZodEffects<ZodString, string>;
+    rfc3339String: () => ZodEffects<ZodString, string>;
+    iso8601Date: () => ZodEffects<ZodString, string, string>;
+    urlHttpsString: () => ZodEffects<ZodString, string, string>;
+    urlHttpOrHttpsString: () => ZodEffects<ZodString, string, string>;
+    language: () => ZodTypeAny;
+    dsgcPayload: () => ZodObject<{
+        certificates: zod.ZodArray<ZodObject<{
+            certificateType: ZodString;
+            country: ZodString;
+            kid: ZodString;
+            rawData: ZodString;
+            signature: ZodString;
+            thumbprint: ZodString;
+            timestamp: ZodString;
+        }, "strip", ZodTypeAny, {
+            certificateType: string;
+            country: string;
+            kid: string;
+            rawData: string;
+            signature: string;
+            thumbprint: string;
+            timestamp: string;
+        }, {
+            certificateType: string;
+            country: string;
+            kid: string;
+            rawData: string;
+            signature: string;
+            thumbprint: string;
+            timestamp: string;
+        }>, "many">;
+    }, "strip", ZodTypeAny, {
+        certificates: {
+            certificateType: string;
+            country: string;
+            kid: string;
+            rawData: string;
+            signature: string;
+            thumbprint: string;
+            timestamp: string;
+        }[];
+    }, {
+        certificates: {
+            certificateType: string;
+            country: string;
+            kid: string;
+            rawData: string;
+            signature: string;
+            thumbprint: string;
+            timestamp: string;
+        }[];
+    }>;
+    dccListPayload: () => zod.ZodArray<ZodObject<{
+        identifier: ZodString;
+        version: ZodString;
+        country: ZodString;
+        hash: ZodString;
+    }, "strip", ZodTypeAny, {
+        identifier: string;
+        version: string;
+        country: string;
+        hash: string;
+    }, {
+        identifier: string;
+        version: string;
+        country: string;
+        hash: string;
+    }>, "many">;
+    dccRulePayload: () => ZodObject<{
+        Identifier: ZodString;
+        Type: ZodString;
+        Country: ZodString;
+        Version: ZodString;
+        SchemaVersion: ZodString;
+        Engine: ZodString;
+        EngineVersion: ZodString;
+        CertificateType: ZodString;
+        Description: zod.ZodArray<ZodObject<{
+            lang: ZodString;
+            desc: ZodString;
+        }, "strip", ZodTypeAny, {
+            lang: string;
+            desc: string;
+        }, {
+            lang: string;
+            desc: string;
+        }>, "many">;
+        ValidFrom: ZodString;
+        ValidTo: ZodString;
+        AffectedFields: zod.ZodArray<ZodString, "many">;
+        Logic: zod.ZodAny;
+    }, "strip", ZodTypeAny, {
+        Identifier: string;
+        Type: string;
+        Country: string;
+        Version: string;
+        SchemaVersion: string;
+        Engine: string;
+        EngineVersion: string;
+        CertificateType: string;
+        Description: {
+            lang: string;
+            desc: string;
+        }[];
+        ValidFrom: string;
+        ValidTo: string;
+        AffectedFields: string[];
+        Logic?: any;
+    }, {
+        Identifier: string;
+        Type: string;
+        Country: string;
+        Version: string;
+        SchemaVersion: string;
+        Engine: string;
+        EngineVersion: string;
+        CertificateType: string;
+        Description: {
+            lang: string;
+            desc: string;
+        }[];
+        ValidFrom: string;
+        ValidTo: string;
+        AffectedFields: string[];
+        Logic?: any;
+    }>;
 };
 export * from 'zod';
 export { z };

package/dist/utils/normalizePath.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (path: string, routePath: string) => string;
 export default _default;
+declare function _default(path: string, routePath: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "5.22.0",
+  "version": "5.23.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -31,10 +31,10 @@
     "@types/response-time": "^2.3.9",
     "@types/swagger-ui-express": "4.1.8",
     "@types/validator": "13.7.1",
-    "axios": "1.16.0",
+    "axios": "1.18.0",
     "axios-rate-limit": "^1.4.0",
     "axios-retry": "^4.5.0",
-    "body-parser": "1.20.4",
+    "body-parser": "1.20.6",
     "busboy": "^1.6.0",
     "cls-rtracer": "^2.6.3",
     "express": "4.22.1",
@@ -53,7 +53,7 @@
     "sequelize": "6.37.8",
     "sqlite3": "6.0.1",
     "swagger-ui-express": "5.0.1",
-    "tar": "7.5.16",
+    "tar": "7.5.19",
     "url-value-parser": "^2.2.0",
     "uuid": "^14.0.0",
     "validator": "13.15.23",
@@ -79,12 +79,14 @@
     "semantic-release": "^25.0.3",
     "semantic-release-monorepo": "8.0.2",
     "supertest": "6.3.4",
-    "typescript": "6.0.2",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "4.1.1"
   },
   "resolutions": {
-    "tar": "7.5.16",
+    "tar": "7.5.19",
+    "body-parser": "1.20.6",
     "lodash": "^4.18.1",
     "qs": "6.15.2",
     "dottie": "2.0.7",
@@ -97,13 +99,13 @@
     "node-forge": "1.4.0",
     "uuid": "^14.0.0",
     "follow-redirects": "^1.16.0",
-    "axios": "1.16.0",
+    "axios": "1.18.0",
     "path-to-regexp": "0.1.13",
     "ip-address": "10.1.1",
     "fast-xml-builder": "^1.1.7",
-    "brace-expansion": "2.0.3",
+    "brace-expansion": "2.1.2",
     "form-data": "4.0.6",
-    "js-yaml": "4.2.0",
+    "js-yaml": "4.3.0",
     "@opentelemetry/core": "2.8.0"
   }
 }