@forklaunch/implementation-worker-bullmq 0.1.0

package/lib/schemas/typebox/bullMqWorker.schema.js

@@ -0,0 +1,104 @@
+import { any, array, boolean, date, enum_, function_, literal, null_, number, optional, promise, record, string, undefined_, union, unknown, void_ } from '@forklaunch/validator/typebox';
+import { SpanKind } from 'bullmq';
+const BullMqWorkerKeepJobsSchema = {
+    age: optional(number),
+    count: optional(number)
+};
+const BullMqWorkerBackoffOptionsSchema = {
+    type: union([literal('fixed'), literal('exponential')]),
+    delay: optional(number)
+};
+const BullMqWorkerDefaultJobOptionsSchema = {
+    timestamp: optional(number),
+    priority: optional(number),
+    delay: optional(number),
+    attempts: optional(number),
+    backoff: optional(union([number, BullMqWorkerBackoffOptionsSchema])),
+    lifo: optional(boolean),
+    removeOnComplete: optional(union([boolean, number, BullMqWorkerKeepJobsSchema])),
+    removeOnFail: optional(union([boolean, number, BullMqWorkerKeepJobsSchema])),
+    keepLogs: optional(number),
+    stackTraceLimit: optional(number),
+    sizeLimit: optional(number)
+};
+const BullMqWorkerAdvancedRepeatOptionsSchema = {
+    repeatStrategy: optional(function_([
+        number,
+        {
+            pattern: optional(string),
+            key: optional(string),
+            limit: optional(number),
+            every: optional(number),
+            immediately: optional(boolean),
+            count: optional(number),
+            offset: optional(number),
+            prevMillis: optional(number),
+            jobId: optional(string),
+            currentDate: optional(date),
+            startDate: optional(date),
+            endDate: optional(date),
+            utc: optional(boolean),
+            tz: optional(string),
+            nthDayOfWeek: optional(number)
+        },
+        optional(string)
+    ], union([number, undefined_, promise(union([number, undefined_]))]))),
+    repeatKeyHashAlgorithm: optional(string)
+};
+const BullMqWorkerTelemetryAttributeValueSchema = union([
+    string,
+    number,
+    boolean,
+    array(union([string, null_, undefined_])),
+    array(union([number, null_, undefined_])),
+    array(union([boolean, null_, undefined_]))
+]);
+const BullMqWorkerTelemetryAttributesSchema = record(string, union([BullMqWorkerTelemetryAttributeValueSchema, undefined_]));
+const BullMqWorkerTelemetrySchema = optional({
+    tracer: {
+        startSpan: function_([
+            string,
+            optional({
+                kind: optional(enum_(SpanKind))
+            }),
+            optional(unknown)
+        ], {
+            setSpanOnContext: function_([unknown], unknown),
+            setAttribute: function_([string, BullMqWorkerTelemetryAttributeValueSchema], void_),
+            setAttributes: function_([BullMqWorkerTelemetryAttributesSchema], void_),
+            addEvent: function_([string, optional(BullMqWorkerTelemetryAttributesSchema)], void_),
+            recordException: function_([unknown, optional(number)], void_),
+            end: function_([], void_)
+        })
+    },
+    contextManager: {
+        with: function_([unknown, function_([any], any)], any),
+        active: function_([], unknown),
+        getMetadata: function_([unknown], string),
+        fromMetadata: function_([unknown, string], unknown)
+    }
+});
+const BullMqWorkerQueueOptionsSchema = {
+    connection: {
+        skipVersionCheck: optional(boolean),
+        url: optional(string)
+    },
+    blockingConnection: optional(boolean),
+    prefix: optional(string),
+    telemetry: BullMqWorkerTelemetrySchema,
+    skipWaitingForReady: optional(boolean),
+    defaultJobOptions: optional(BullMqWorkerDefaultJobOptionsSchema),
+    streams: optional({
+        events: {
+            maxLen: number
+        }
+    }),
+    skipMetasUpdate: optional(boolean),
+    settings: optional(BullMqWorkerAdvancedRepeatOptionsSchema)
+};
+export const BullMqWorkerOptionsSchema = {
+    ...BullMqWorkerQueueOptionsSchema,
+    backoffType: union([literal('exponential'), literal('fixed')]),
+    retries: number,
+    interval: number
+};

package/lib/schemas/zod/bullMqWorker.schema.d.ts

@@ -0,0 +1,306 @@
+import { SpanKind } from 'bullmq';
+export declare const BullMqWorkerOptionsSchema: {
+    backoffType: import("zod").ZodUnion<[import("zod").ZodLiteral<"exponential">, import("zod").ZodLiteral<"fixed">]>;
+    retries: import("zod").ZodNumber;
+    interval: import("zod").ZodNumber;
+    connection: {
+        skipVersionCheck: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+        url: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    blockingConnection: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+    prefix: import("zod").ZodOptional<import("zod").ZodString>;
+    telemetry: import("zod").ZodOptional<import("zod").ZodObject<{
+        tracer: import("zod").ZodObject<{
+            startSpan: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                kind: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodLiteral<SpanKind.INTERNAL> | import("zod").ZodLiteral<SpanKind.SERVER> | import("zod").ZodLiteral<SpanKind.CLIENT> | import("zod").ZodLiteral<SpanKind.PRODUCER> | import("zod").ZodLiteral<SpanKind.CONSUMER>]>>;
+            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+                kind?: SpanKind | undefined;
+            }, {
+                kind?: SpanKind | undefined;
+            }>>, import("zod").ZodOptional<import("zod").ZodUnknown>], null>, import("zod").ZodObject<{
+                setSpanOnContext: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodUnknown], null>, import("zod").ZodUnknown>;
+                setAttribute: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">]>], null>, import("zod").ZodVoid>;
+                setAttributes: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">]>, import("zod").ZodUndefined]>>], null>, import("zod").ZodVoid>;
+                addEvent: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">, import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodNull, import("zod").ZodUndefined]>, "many">]>, import("zod").ZodUndefined]>>>], null>, import("zod").ZodVoid>;
+                recordException: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodOptional<import("zod").ZodNumber>], null>, import("zod").ZodVoid>;
+                end: import("zod").ZodFunction<import("zod").ZodTuple<[], null>, import("zod").ZodVoid>;
+            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: unknown) => void;
+                setAttributes: (args_0: Record<string, unknown>) => void;
+                addEvent: (args_0: string, args_1: Record<string, unknown> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            }, {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[]) => void;
+                setAttributes: (args_0: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined>) => void;
+                addEvent: (args_0: string, args_1: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            }>>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            startSpan: (args_0: string, args_1: {
+                kind?: SpanKind | undefined;
+            } | undefined, args_2: unknown) => {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: unknown) => void;
+                setAttributes: (args_0: Record<string, unknown>) => void;
+                addEvent: (args_0: string, args_1: Record<string, unknown> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            };
+        }, {
+            startSpan: (args_0: string, args_1: {
+                kind?: SpanKind | undefined;
+            } | undefined, args_2: unknown) => {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[]) => void;
+                setAttributes: (args_0: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined>) => void;
+                addEvent: (args_0: string, args_1: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            };
+        }>;
+        contextManager: import("zod").ZodObject<{
+            with: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodAny], null>, import("zod").ZodAny>], null>, import("zod").ZodAny>;
+            active: import("zod").ZodFunction<import("zod").ZodTuple<[], null>, import("zod").ZodUnknown>;
+            getMetadata: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodUnknown], null>, import("zod").ZodString>;
+            fromMetadata: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodString], null>, import("zod").ZodUnknown>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            active: () => unknown;
+            with: (args_0: unknown, args_1: (args_0: any) => any) => any;
+            getMetadata: (args_0: unknown) => string;
+            fromMetadata: (args_0: unknown, args_1: string) => unknown;
+        }, {
+            active: () => unknown;
+            with: (args_0: unknown, args_1: (args_0: any) => any) => any;
+            getMetadata: (args_0: unknown) => string;
+            fromMetadata: (args_0: unknown, args_1: string) => unknown;
+        }>;
+    }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+        tracer: {
+            startSpan: (args_0: string, args_1: {
+                kind?: SpanKind | undefined;
+            } | undefined, args_2: unknown) => {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: unknown) => void;
+                setAttributes: (args_0: Record<string, unknown>) => void;
+                addEvent: (args_0: string, args_1: Record<string, unknown> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            };
+        };
+        contextManager: {
+            active: () => unknown;
+            with: (args_0: unknown, args_1: (args_0: any) => any) => any;
+            getMetadata: (args_0: unknown) => string;
+            fromMetadata: (args_0: unknown, args_1: string) => unknown;
+        };
+    }, {
+        tracer: {
+            startSpan: (args_0: string, args_1: {
+                kind?: SpanKind | undefined;
+            } | undefined, args_2: unknown) => {
+                setSpanOnContext: (args_0: unknown) => unknown;
+                setAttribute: (args_0: string, args_1: string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[]) => void;
+                setAttributes: (args_0: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined>) => void;
+                addEvent: (args_0: string, args_1: Record<string, string | number | boolean | (string | null | undefined)[] | (number | null | undefined)[] | (boolean | null | undefined)[] | undefined> | undefined) => void;
+                recordException: (args_0: unknown, args_1: number | undefined) => void;
+                end: () => void;
+            };
+        };
+        contextManager: {
+            active: () => unknown;
+            with: (args_0: unknown, args_1: (args_0: any) => any) => any;
+            getMetadata: (args_0: unknown) => string;
+            fromMetadata: (args_0: unknown, args_1: string) => unknown;
+        };
+    }>>;
+    skipWaitingForReady: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+    defaultJobOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        timestamp: import("zod").ZodOptional<import("zod").ZodNumber>;
+        priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+        delay: import("zod").ZodOptional<import("zod").ZodNumber>;
+        attempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+        backoff: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodObject<{
+            type: import("zod").ZodUnion<[import("zod").ZodLiteral<"fixed">, import("zod").ZodLiteral<"exponential">]>;
+            delay: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            type: "exponential" | "fixed";
+            delay?: number | undefined;
+        }, {
+            type: "exponential" | "fixed";
+            delay?: number | undefined;
+        }>]>>;
+        lifo: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+        removeOnComplete: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodNumber, import("zod").ZodObject<{
+            age: import("zod").ZodOptional<import("zod").ZodNumber>;
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            count?: number | undefined;
+            age?: number | undefined;
+        }, {
+            count?: number | undefined;
+            age?: number | undefined;
+        }>]>>;
+        removeOnFail: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>, import("zod").ZodNumber, import("zod").ZodObject<{
+            age: import("zod").ZodOptional<import("zod").ZodNumber>;
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            count?: number | undefined;
+            age?: number | undefined;
+        }, {
+            count?: number | undefined;
+            age?: number | undefined;
+        }>]>>;
+        keepLogs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stackTraceLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        sizeLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+        delay?: number | undefined;
+        timestamp?: number | undefined;
+        priority?: number | undefined;
+        attempts?: number | undefined;
+        backoff?: number | {
+            type: "exponential" | "fixed";
+            delay?: number | undefined;
+        } | undefined;
+        lifo?: boolean | undefined;
+        removeOnComplete?: number | boolean | {
+            count?: number | undefined;
+            age?: number | undefined;
+        } | undefined;
+        removeOnFail?: number | boolean | {
+            count?: number | undefined;
+            age?: number | undefined;
+        } | undefined;
+        keepLogs?: number | undefined;
+        stackTraceLimit?: number | undefined;
+        sizeLimit?: number | undefined;
+    }, {
+        delay?: number | undefined;
+        timestamp?: number | undefined;
+        priority?: number | undefined;
+        attempts?: number | undefined;
+        backoff?: number | {
+            type: "exponential" | "fixed";
+            delay?: number | undefined;
+        } | undefined;
+        lifo?: unknown;
+        removeOnComplete?: unknown;
+        removeOnFail?: unknown;
+        keepLogs?: number | undefined;
+        stackTraceLimit?: number | undefined;
+        sizeLimit?: number | undefined;
+    }>>;
+    streams: import("zod").ZodOptional<import("zod").ZodObject<{
+        events: import("zod").ZodObject<{
+            maxLen: import("zod").ZodNumber;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            maxLen: number;
+        }, {
+            maxLen: number;
+        }>;
+    }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+        events: {
+            maxLen: number;
+        };
+    }, {
+        events: {
+            maxLen: number;
+        };
+    }>>;
+    skipMetasUpdate: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+    settings: import("zod").ZodOptional<import("zod").ZodObject<{
+        repeatStrategy: import("zod").ZodOptional<import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodObject<{
+            pattern: import("zod").ZodOptional<import("zod").ZodString>;
+            key: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            every: import("zod").ZodOptional<import("zod").ZodNumber>;
+            immediately: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+            prevMillis: import("zod").ZodOptional<import("zod").ZodNumber>;
+            jobId: import("zod").ZodOptional<import("zod").ZodString>;
+            currentDate: import("zod").ZodOptional<import("zod").ZodDate>;
+            startDate: import("zod").ZodOptional<import("zod").ZodDate>;
+            endDate: import("zod").ZodOptional<import("zod").ZodDate>;
+            utc: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>>;
+            tz: import("zod").ZodOptional<import("zod").ZodString>;
+            nthDayOfWeek: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+            jobId?: string | undefined;
+            prevMillis?: number | undefined;
+            key?: string | undefined;
+            currentDate?: Date | undefined;
+            startDate?: Date | undefined;
+            endDate?: Date | undefined;
+            utc?: boolean | undefined;
+            tz?: string | undefined;
+            nthDayOfWeek?: number | undefined;
+            pattern?: string | undefined;
+            limit?: number | undefined;
+            every?: number | undefined;
+            immediately?: boolean | undefined;
+            count?: number | undefined;
+            offset?: number | undefined;
+        }, {
+            jobId?: string | undefined;
+            prevMillis?: number | undefined;
+            key?: string | undefined;
+            currentDate?: Date | undefined;
+            startDate?: Date | undefined;
+            endDate?: Date | undefined;
+            utc?: unknown;
+            tz?: string | undefined;
+            nthDayOfWeek?: number | undefined;
+            pattern?: string | undefined;
+            limit?: number | undefined;
+            every?: number | undefined;
+            immediately?: unknown;
+            count?: number | undefined;
+            offset?: number | undefined;
+        }>, import("zod").ZodOptional<import("zod").ZodString>], null>, import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodUndefined, import("zod").ZodPromise<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodUndefined]>>]>>>;
+        repeatKeyHashAlgorithm: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+        repeatStrategy?: ((args_0: number, args_1: {
+            jobId?: string | undefined;
+            prevMillis?: number | undefined;
+            key?: string | undefined;
+            currentDate?: Date | undefined;
+            startDate?: Date | undefined;
+            endDate?: Date | undefined;
+            utc?: unknown;
+            tz?: string | undefined;
+            nthDayOfWeek?: number | undefined;
+            pattern?: string | undefined;
+            limit?: number | undefined;
+            every?: number | undefined;
+            immediately?: unknown;
+            count?: number | undefined;
+            offset?: number | undefined;
+        }, args_2: string | undefined) => number | Promise<number | undefined> | undefined) | undefined;
+        repeatKeyHashAlgorithm?: string | undefined;
+    }, {
+        repeatStrategy?: ((args_0: number, args_1: {
+            jobId?: string | undefined;
+            prevMillis?: number | undefined;
+            key?: string | undefined;
+            currentDate?: Date | undefined;
+            startDate?: Date | undefined;
+            endDate?: Date | undefined;
+            utc?: boolean | undefined;
+            tz?: string | undefined;
+            nthDayOfWeek?: number | undefined;
+            pattern?: string | undefined;
+            limit?: number | undefined;
+            every?: number | undefined;
+            immediately?: boolean | undefined;
+            count?: number | undefined;
+            offset?: number | undefined;
+        }, args_2: string | undefined) => number | Promise<number | undefined> | undefined) | undefined;
+        repeatKeyHashAlgorithm?: string | undefined;
+    }>>;
+};
+//# sourceMappingURL=bullMqWorker.schema.d.ts.map

package/lib/schemas/zod/bullMqWorker.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullMqWorker.schema.d.ts","sourceRoot":"","sources":["../../../schemas/zod/bullMqWorker.schema.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAgIlC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrC,CAAC"}

package/lib/schemas/zod/bullMqWorker.schema.js

@@ -0,0 +1,104 @@
+import { any, array, boolean, date, enum_, function_, literal, null_, number, optional, promise, record, string, undefined_, union, unknown, void_ } from '@forklaunch/validator/zod';
+import { SpanKind } from 'bullmq';
+const BullMqWorkerKeepJobsSchema = {
+    age: optional(number),
+    count: optional(number)
+};
+const BullMqWorkerBackoffOptionsSchema = {
+    type: union([literal('fixed'), literal('exponential')]),
+    delay: optional(number)
+};
+const BullMqWorkerDefaultJobOptionsSchema = {
+    timestamp: optional(number),
+    priority: optional(number),
+    delay: optional(number),
+    attempts: optional(number),
+    backoff: optional(union([number, BullMqWorkerBackoffOptionsSchema])),
+    lifo: optional(boolean),
+    removeOnComplete: optional(union([boolean, number, BullMqWorkerKeepJobsSchema])),
+    removeOnFail: optional(union([boolean, number, BullMqWorkerKeepJobsSchema])),
+    keepLogs: optional(number),
+    stackTraceLimit: optional(number),
+    sizeLimit: optional(number)
+};
+const BullMqWorkerAdvancedRepeatOptionsSchema = {
+    repeatStrategy: optional(function_([
+        number,
+        {
+            pattern: optional(string),
+            key: optional(string),
+            limit: optional(number),
+            every: optional(number),
+            immediately: optional(boolean),
+            count: optional(number),
+            offset: optional(number),
+            prevMillis: optional(number),
+            jobId: optional(string),
+            currentDate: optional(date),
+            startDate: optional(date),
+            endDate: optional(date),
+            utc: optional(boolean),
+            tz: optional(string),
+            nthDayOfWeek: optional(number)
+        },
+        optional(string)
+    ], union([number, undefined_, promise(union([number, undefined_]))]))),
+    repeatKeyHashAlgorithm: optional(string)
+};
+const BullMqWorkerTelemetryAttributeValueSchema = union([
+    string,
+    number,
+    boolean,
+    array(union([string, null_, undefined_])),
+    array(union([number, null_, undefined_])),
+    array(union([boolean, null_, undefined_]))
+]);
+const BullMqWorkerTelemetryAttributesSchema = record(string, union([BullMqWorkerTelemetryAttributeValueSchema, undefined_]));
+const BullMqWorkerTelemetrySchema = optional({
+    tracer: {
+        startSpan: function_([
+            string,
+            optional({
+                kind: optional(enum_(SpanKind))
+            }),
+            optional(unknown)
+        ], {
+            setSpanOnContext: function_([unknown], unknown),
+            setAttribute: function_([string, BullMqWorkerTelemetryAttributeValueSchema], void_),
+            setAttributes: function_([BullMqWorkerTelemetryAttributesSchema], void_),
+            addEvent: function_([string, optional(BullMqWorkerTelemetryAttributesSchema)], void_),
+            recordException: function_([unknown, optional(number)], void_),
+            end: function_([], void_)
+        })
+    },
+    contextManager: {
+        with: function_([unknown, function_([any], any)], any),
+        active: function_([], unknown),
+        getMetadata: function_([unknown], string),
+        fromMetadata: function_([unknown, string], unknown)
+    }
+});
+const BullMqWorkerQueueOptionsSchema = {
+    connection: {
+        skipVersionCheck: optional(boolean),
+        url: optional(string)
+    },
+    blockingConnection: optional(boolean),
+    prefix: optional(string),
+    telemetry: BullMqWorkerTelemetrySchema,
+    skipWaitingForReady: optional(boolean),
+    defaultJobOptions: optional(BullMqWorkerDefaultJobOptionsSchema),
+    streams: optional({
+        events: {
+            maxLen: number
+        }
+    }),
+    skipMetasUpdate: optional(boolean),
+    settings: optional(BullMqWorkerAdvancedRepeatOptionsSchema)
+};
+export const BullMqWorkerOptionsSchema = {
+    ...BullMqWorkerQueueOptionsSchema,
+    backoffType: union([literal('exponential'), literal('fixed')]),
+    retries: number,
+    interval: number
+};