nmtjs 0.15.0-beta.2 → 0.15.0-beta.21

package/dist/runtime/jobs/router.d.ts

@@ -0,0 +1,266 @@
+import type { MaybePromise } from '@nmtjs/common';
+import type { TProcedureContract, TRouterContract } from '@nmtjs/contract';
+import type { Dependencies, DependencyContext, Metadata } from '@nmtjs/core';
+import type { NullableType, OptionalType } from '@nmtjs/type';
+import type { NeverType } from '@nmtjs/type/never';
+import { t } from '@nmtjs/type';
+import type { AnyGuard } from '../application/api/guards.ts';
+import type { AnyMiddleware } from '../application/api/middlewares.ts';
+import type { Router } from '../application/api/router.ts';
+import type { AnyJob } from './job.ts';
+/** Base operation config shared by all operations */
+export type BaseOperationConfig<Deps extends Dependencies = {}> = {
+    dependencies?: Deps;
+    guards?: AnyGuard[];
+    middlewares?: AnyMiddleware[];
+    metadata?: Metadata[];
+    timeout?: number;
+};
+/** List operation config (read-only, no hooks) */
+export type ListOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps>;
+/** Get operation config (read-only, no hooks) */
+export type GetOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps>;
+/** Info operation config (read-only, no hooks) */
+export type InfoOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps>;
+/** Add queue options */
+export type AddQueueOptions = {
+    priority?: number;
+    attempts?: number;
+    delay?: number;
+};
+/** Add operation config with before/after hooks */
+export type AddOperationConfig<T extends AnyJob = AnyJob, Deps extends Dependencies = {}> = BaseOperationConfig<Deps> & {
+    beforeAdd?: (ctx: DependencyContext<Deps>, input: T['_']['input']) => MaybePromise<T['_']['input']>;
+    afterAdd?: (ctx: DependencyContext<Deps>, result: {
+        id: string;
+        name: string;
+    }, input: T['_']['input']) => MaybePromise<void>;
+    options?: AddQueueOptions;
+};
+/** Remove operation config with before/after hooks */
+export type RemoveOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps> & {
+    beforeRemove?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+    afterRemove?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+};
+/** Retry operation config with before/after hooks */
+export type RetryOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps> & {
+    clearState?: boolean;
+    beforeRetry?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+        clearState?: boolean;
+    }) => MaybePromise<void>;
+    afterRetry?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+        clearState?: boolean;
+    }) => MaybePromise<void>;
+};
+/** Cancel operation config with before/after hooks */
+export type CancelOperationConfig<Deps extends Dependencies = {}> = BaseOperationConfig<Deps> & {
+    beforeCancel?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+    afterCancel?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+};
+/** All operations for a job (false = disabled) */
+export type JobOperations<T extends AnyJob = AnyJob> = {
+    info?: InfoOperationConfig<any> | false;
+    list?: ListOperationConfig<any> | false;
+    get?: GetOperationConfig<any> | false;
+    add?: AddOperationConfig<T, any> | false;
+    retry?: RetryOperationConfig<any> | false;
+    cancel?: CancelOperationConfig<any> | false;
+    remove?: RemoveOperationConfig<any> | false;
+};
+/** Default operations config */
+export type DefaultOperations = {
+    info?: InfoOperationConfig<any> | false;
+    list?: ListOperationConfig<any> | false;
+    get?: GetOperationConfig<any> | false;
+    add?: AddOperationConfig<AnyJob, any> | false;
+    retry?: RetryOperationConfig<any> | false;
+    cancel?: CancelOperationConfig<any> | false;
+    remove?: RemoveOperationConfig<any> | false;
+};
+/** Options for createJobsRouter */
+export type CreateJobsRouterOptions<Jobs extends Record<string, AnyJob>> = {
+    jobs: Jobs;
+    guards?: AnyGuard[];
+    middlewares?: AnyMiddleware[];
+    defaults?: DefaultOperations;
+    overrides?: {
+        [K in keyof Jobs]?: JobOperations<Jobs[K]>;
+    };
+};
+/** Type-level representation of createJobItemSchema output */
+type JobItemSchemaType<T extends AnyJob> = t.ObjectType<{
+    id: t.StringType;
+    queueName: t.StringType;
+    priority: OptionalType<t.NumberType>;
+    progress: t.AnyType;
+    name: t.StringType;
+    data: T['input'];
+    returnvalue: OptionalType<NullableType<T['output']>>;
+    attemptsMade: t.NumberType;
+    processedOn: OptionalType<t.NumberType>;
+    finishedOn: OptionalType<t.NumberType>;
+    failedReason: OptionalType<t.StringType>;
+    stacktrace: OptionalType<t.ArrayType<t.StringType>>;
+    status: t.StringType;
+}>;
+/** Type-level representation of createListOutputSchema output */
+type ListOutputSchemaType<T extends AnyJob> = t.ObjectType<{
+    items: t.ArrayType<JobItemSchemaType<T>>;
+    page: t.NumberType;
+    limit: t.NumberType;
+    pages: t.NumberType;
+    total: t.NumberType;
+}>;
+/** Type-level representation of createGetOutputSchema output */
+type GetOutputSchemaType<T extends AnyJob> = NullableType<JobItemSchemaType<T>>;
+/** Type-level representation of infoOutputSchema */
+type InfoOutputSchemaType = typeof infoOutputSchema;
+/** Type-level representation of createAddInputSchema output */
+type AddInputSchemaType<T extends AnyJob> = t.ObjectType<{
+    data: T['input'];
+    jobId: OptionalType<t.StringType>;
+    priority: OptionalType<t.NumberType>;
+    delay: OptionalType<t.NumberType>;
+}>;
+/** Operations contract for a single job - now properly typed per job */
+type JobOperationsProcedures<T extends AnyJob> = {
+    info: TProcedureContract<NeverType, InfoOutputSchemaType>;
+    list: TProcedureContract<typeof listInputSchema, ListOutputSchemaType<T>>;
+    get: TProcedureContract<typeof getInputSchema, GetOutputSchemaType<T>>;
+    add: TProcedureContract<AddInputSchemaType<T>, typeof addOutputSchema>;
+    retry: TProcedureContract<typeof retryInputSchema, NeverType>;
+    cancel: TProcedureContract<typeof idInputSchema, NeverType>;
+    remove: TProcedureContract<typeof idInputSchema, NeverType>;
+};
+/** Router contract for a single job's operations */
+type JobRouterContract<T extends AnyJob> = TRouterContract<JobOperationsProcedures<T>>;
+/** Full jobs router contract mapping job names to their operation routers */
+type JobsRouterContract<Jobs extends Record<string, AnyJob>> = TRouterContract<{
+    [K in keyof Jobs]: JobRouterContract<Jobs[K]>;
+}>;
+/** Return type for createJobsRouter */
+export type JobsRouter<Jobs extends Record<string, AnyJob>> = Router<JobsRouterContract<Jobs>>;
+/** Input schema for list operation */
+declare const listInputSchema: t.ObjectType<{
+    page: OptionalType<t.NumberType>;
+    limit: OptionalType<t.NumberType>;
+    state: OptionalType<t.ArrayType<t.StringType>>;
+}>;
+/** Input schema for get operation */
+declare const getInputSchema: t.ObjectType<{
+    id: t.StringType;
+}>;
+/** Output schema for add operation */
+declare const addOutputSchema: t.ObjectType<{
+    id: t.StringType;
+    name: t.StringType;
+}>;
+/** Input schema for retry operation */
+declare const retryInputSchema: t.ObjectType<{
+    id: t.StringType;
+    clearState: OptionalType<t.BooleanType>;
+}>;
+/** Input schema for cancel/remove operations */
+declare const idInputSchema: t.ObjectType<{
+    id: t.StringType;
+}>;
+/** Output schema for info operation */
+declare const infoOutputSchema: t.ObjectType<{
+    name: t.StringType;
+    steps: t.ArrayType<t.ObjectType<{
+        label: OptionalType<t.StringType>;
+        conditional: t.BooleanType;
+    }>>;
+}>;
+/**
+ * Helper function to create a type-safe operation config with dependencies.
+ * Use this when you need custom dependencies for hooks.
+ *
+ * @example
+ * ```ts
+ * add: jobOperation({
+ *   dependencies: { userService, auditLog },
+ *   beforeAdd: async (ctx, input) => {
+ *     return { ...input, createdBy: ctx.userService.getCurrentId() }
+ *   },
+ * })
+ * ```
+ */
+export declare function jobOperation<Deps extends Dependencies, T extends AnyJob = AnyJob>(config: BaseOperationConfig<Deps> & {
+    beforeAdd?: (ctx: DependencyContext<Deps>, input: T['_']['input']) => MaybePromise<T['_']['input']>;
+    afterAdd?: (ctx: DependencyContext<Deps>, result: {
+        id: string;
+        name: string;
+    }, input: T['_']['input']) => MaybePromise<void>;
+    options?: AddQueueOptions;
+    beforeRemove?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+    afterRemove?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+    clearState?: boolean;
+    beforeRetry?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+        clearState?: boolean;
+    }) => MaybePromise<void>;
+    afterRetry?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+        clearState?: boolean;
+    }) => MaybePromise<void>;
+    beforeCancel?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+    afterCancel?: (ctx: DependencyContext<Deps>, params: {
+        id: string;
+    }) => MaybePromise<void>;
+}): typeof config;
+/**
+ * Creates a router with CRUD-like operations for multiple jobs.
+ *
+ * @example
+ * ```ts
+ * const jobsRouter = createJobsRouter({
+ *   jobs: [userJob, emailJob] as const,
+ *   guards: [authGuard],
+ *   defaults: {
+ *     list: {},
+ *     get: {},
+ *     add: {},
+ *     retry: { guards: [adminGuard] },
+ *     cancel: { guards: [adminGuard] },
+ *     remove: false,
+ *   },
+ *   overrides: {
+ *     userProcessing: {
+ *       add: jobOperation({
+ *         dependencies: { userService },
+ *         beforeAdd: async (ctx, input) => ({
+ *           ...input,
+ *           userId: ctx.userService.getCurrentId(),
+ *         }),
+ *       }),
+ *     },
+ *   },
+ * })
+ *
+ * // Use in your router
+ * createRouter({
+ *   routes: {
+ *     jobs: jobsRouter,
+ *   }
+ * })
+ * ```
+ */
+export declare function createJobsRouter<const Jobs extends Record<string, AnyJob>>(options: CreateJobsRouterOptions<Jobs>): JobsRouter<Jobs>;
+export {};

package/dist/runtime/jobs/router.js

@@ -0,0 +1,432 @@
+import { CoreInjectables } from '@nmtjs/core';
+import { t } from '@nmtjs/type';
+import { createProcedure } from "../application/api/procedure.js";
+import { createRouter } from "../application/api/router.js";
+import { jobManager } from "../injectables.js";
+// ============================================================================
+// Schemas
+// ============================================================================
+/** Input schema for list operation */
+const listInputSchema = t.object({
+    page: t.number().optional(),
+    limit: t.number().optional(),
+    state: t.array(t.string()).optional(),
+});
+/** Input schema for get operation */
+const getInputSchema = t.object({ id: t.string() });
+/** Output schema for add operation */
+const addOutputSchema = t.object({ id: t.string(), name: t.string() });
+/** Input schema for retry operation */
+const retryInputSchema = t.object({
+    id: t.string(),
+    clearState: t.boolean().optional(),
+});
+/** Input schema for cancel/remove operations */
+const idInputSchema = t.object({ id: t.string() });
+/** Output schema for info operation */
+const infoOutputSchema = t.object({
+    name: t.string(),
+    steps: t.array(t.object({ label: t.string().optional(), conditional: t.boolean() })),
+});
+/** JobItem schema for list/get responses - typed per job */
+function createJobItemSchema(job) {
+    return t.object({
+        id: t.string(),
+        queueName: t.string(),
+        priority: t.number().optional(),
+        progress: t.any(),
+        name: t.string(),
+        data: job.input,
+        returnvalue: job.output.nullish(),
+        attemptsMade: t.number(),
+        processedOn: t.number().optional(),
+        finishedOn: t.number().optional(),
+        failedReason: t.string().optional(),
+        stacktrace: t.array(t.string()).optional(),
+        status: t.string(),
+    });
+}
+/** Creates list output schema for a specific job */
+function createListOutputSchema(job) {
+    return t.object({
+        items: t.array(createJobItemSchema(job)),
+        page: t.number(),
+        limit: t.number(),
+        pages: t.number(),
+        total: t.number(),
+    });
+}
+/** Creates get output schema for a specific job */
+function createGetOutputSchema(job) {
+    return createJobItemSchema(job).nullable();
+}
+/** Creates add input schema for a specific job */
+function createAddInputSchema(job) {
+    return t.object({
+        data: job.input,
+        jobId: t.string().optional(),
+        priority: t.number().optional(),
+        delay: t.number().optional(),
+    });
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Helper function to create a type-safe operation config with dependencies.
+ * Use this when you need custom dependencies for hooks.
+ *
+ * @example
+ * ```ts
+ * add: jobOperation({
+ *   dependencies: { userService, auditLog },
+ *   beforeAdd: async (ctx, input) => {
+ *     return { ...input, createdBy: ctx.userService.getCurrentId() }
+ *   },
+ * })
+ * ```
+ */
+export function jobOperation(config) {
+    return config;
+}
+function createInfoProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        output: infoOutputSchema,
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: (ctx) => {
+            ctx.logger.trace({ jobName: job.options.name }, 'Getting job info');
+            return ctx.jobManager.getInfo(job);
+        },
+    });
+}
+function createListProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: listInputSchema,
+        output: createListOutputSchema(job),
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            ctx.logger.debug({
+                jobName: job.options.name,
+                page: input.page,
+                limit: input.limit,
+                state: input.state,
+            }, 'Listing jobs');
+            const result = await ctx.jobManager.list(job, {
+                page: input.page,
+                limit: input.limit,
+                state: input.state,
+            });
+            ctx.logger.debug({ jobName: job.options.name, total: result.total, pages: result.pages }, 'Jobs listed');
+            return result;
+        },
+    });
+}
+function createGetProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: getInputSchema,
+        output: createGetOutputSchema(job),
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Getting job');
+            const result = await ctx.jobManager.get(job, input.id);
+            ctx.logger.trace({ jobName: job.options.name, id: input.id, found: result !== null }, 'Job retrieved');
+            return result;
+        },
+    });
+}
+function createAddProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: createAddInputSchema(job),
+        output: addOutputSchema,
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            let jobData = input.data;
+            ctx.logger.debug({
+                jobName: job.options.name,
+                jobId: input.jobId,
+                priority: input.priority,
+            }, 'Adding job');
+            // Call beforeAdd hook if provided
+            if (config.beforeAdd) {
+                ctx.logger.debug({ jobName: job.options.name }, 'Running beforeAdd hook');
+                jobData = await config.beforeAdd(ctx, jobData);
+            }
+            const queueResult = await ctx.jobManager.add(job, jobData, {
+                jobId: input.jobId,
+                priority: input.priority ?? config.options?.priority,
+                delay: input.delay ?? config.options?.delay,
+                attempts: config.options?.attempts,
+            });
+            const result = { id: queueResult.id, name: queueResult.name };
+            ctx.logger.info({ jobName: job.options.name, id: result.id }, 'Job added');
+            // Call afterAdd hook if provided
+            if (config.afterAdd) {
+                ctx.logger.trace({ jobName: job.options.name, id: result.id }, 'Running afterAdd hook');
+                await config.afterAdd(ctx, result, jobData);
+            }
+            return result;
+        },
+    });
+}
+function createRetryProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: retryInputSchema,
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            const clearState = input.clearState ?? config.clearState;
+            ctx.logger.debug({ jobName: job.options.name, id: input.id, clearState }, 'Retrying job');
+            // Call beforeRetry hook if provided
+            if (config.beforeRetry) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running beforeRetry hook');
+                await config.beforeRetry(ctx, { id: input.id, clearState });
+            }
+            await ctx.jobManager.retry(job, input.id, { clearState });
+            ctx.logger.info({ jobName: job.options.name, id: input.id }, 'Job retried');
+            // Call afterRetry hook if provided
+            if (config.afterRetry) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running afterRetry hook');
+                await config.afterRetry(ctx, { id: input.id, clearState });
+            }
+        },
+    });
+}
+function createCancelProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: idInputSchema,
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            ctx.logger.debug({ jobName: job.options.name, id: input.id }, 'Canceling job');
+            // Call beforeCancel hook if provided
+            if (config.beforeCancel) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running beforeCancel hook');
+                await config.beforeCancel(ctx, { id: input.id });
+            }
+            await ctx.jobManager.cancel(job, input.id);
+            ctx.logger.info({ jobName: job.options.name, id: input.id }, 'Job canceled');
+            // Call afterCancel hook if provided
+            if (config.afterCancel) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running afterCancel hook');
+                await config.afterCancel(ctx, { id: input.id });
+            }
+        },
+    });
+}
+function createRemoveProcedure(job, config = {}, shared) {
+    const allGuards = [...(shared.guards ?? []), ...(config.guards ?? [])];
+    const allMiddlewares = [
+        ...(shared.middlewares ?? []),
+        ...(config.middlewares ?? []),
+    ];
+    const deps = { jobManager, logger: CoreInjectables.logger };
+    return createProcedure({
+        input: idInputSchema,
+        dependencies: { ...deps, ...(config.dependencies ?? {}) },
+        guards: allGuards,
+        middlewares: allMiddlewares,
+        metadata: config.metadata,
+        timeout: config.timeout,
+        handler: async (ctx, input) => {
+            ctx.logger.debug({ jobName: job.options.name, id: input.id }, 'Removing job');
+            // Call beforeRemove hook if provided
+            if (config.beforeRemove) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running beforeRemove hook');
+                await config.beforeRemove(ctx, { id: input.id });
+            }
+            await ctx.jobManager.remove(job, input.id);
+            ctx.logger.info({ jobName: job.options.name, id: input.id }, 'Job removed');
+            // Call afterRemove hook if provided
+            if (config.afterRemove) {
+                ctx.logger.trace({ jobName: job.options.name, id: input.id }, 'Running afterRemove hook');
+                await config.afterRemove(ctx, { id: input.id });
+            }
+        },
+    });
+}
+// ============================================================================
+// Main router factory
+// ============================================================================
+/**
+ * Merge default operations with job-specific overrides
+ */
+function mergeOperations(defaults = {}, overrides = {}) {
+    const result = {};
+    const ops = [
+        'info',
+        'list',
+        'get',
+        'add',
+        'retry',
+        'cancel',
+        'remove',
+    ];
+    for (const op of ops) {
+        const override = overrides[op];
+        const defaultOp = defaults[op];
+        if (override === false) {
+            result[op] = false;
+        }
+        else if (override !== undefined) {
+            // Override provided - use it (merged with default base config if both are objects)
+            if (defaultOp &&
+                defaultOp !== false &&
+                typeof override === 'object') {
+                result[op] = {
+                    ...defaultOp,
+                    ...override,
+                    guards: [
+                        ...(defaultOp.guards ?? []),
+                        ...(override.guards ?? []),
+                    ],
+                    middlewares: [
+                        ...(defaultOp.middlewares ?? []),
+                        ...(override.middlewares ?? []),
+                    ],
+                };
+            }
+            else {
+                result[op] = override;
+            }
+        }
+        else if (defaultOp !== undefined) {
+            result[op] = defaultOp;
+        }
+        // else: undefined = use default behavior (enabled with empty config)
+    }
+    return result;
+}
+/**
+ * Creates a router with CRUD-like operations for multiple jobs.
+ *
+ * @example
+ * ```ts
+ * const jobsRouter = createJobsRouter({
+ *   jobs: [userJob, emailJob] as const,
+ *   guards: [authGuard],
+ *   defaults: {
+ *     list: {},
+ *     get: {},
+ *     add: {},
+ *     retry: { guards: [adminGuard] },
+ *     cancel: { guards: [adminGuard] },
+ *     remove: false,
+ *   },
+ *   overrides: {
+ *     userProcessing: {
+ *       add: jobOperation({
+ *         dependencies: { userService },
+ *         beforeAdd: async (ctx, input) => ({
+ *           ...input,
+ *           userId: ctx.userService.getCurrentId(),
+ *         }),
+ *       }),
+ *     },
+ *   },
+ * })
+ *
+ * // Use in your router
+ * createRouter({
+ *   routes: {
+ *     jobs: jobsRouter,
+ *   }
+ * })
+ * ```
+ */
+export function createJobsRouter(options) {
+    const { jobs, guards: sharedGuards = [], middlewares: sharedMiddlewares = [], defaults = {}, overrides = {}, } = options;
+    const routes = {};
+    const shared = { guards: sharedGuards, middlewares: sharedMiddlewares };
+    for (const jobName in jobs) {
+        const job = jobs[jobName];
+        const jobOverrides = overrides[jobName] ?? {};
+        // Merge defaults with job-specific overrides
+        const operations = mergeOperations(defaults, jobOverrides);
+        const jobRoutes = {};
+        // Generate each enabled operation
+        if (operations.info !== false) {
+            jobRoutes.info = createInfoProcedure(job, operations.info, shared);
+        }
+        if (operations.list !== false) {
+            jobRoutes.list = createListProcedure(job, operations.list, shared);
+        }
+        if (operations.get !== false) {
+            jobRoutes.get = createGetProcedure(job, operations.get, shared);
+        }
+        if (operations.add !== false) {
+            jobRoutes.add = createAddProcedure(job, operations.add, shared);
+        }
+        if (operations.retry !== false) {
+            jobRoutes.retry = createRetryProcedure(job, operations.retry, shared);
+        }
+        if (operations.cancel !== false) {
+            jobRoutes.cancel = createCancelProcedure(job, operations.cancel, shared);
+        }
+        if (operations.remove !== false) {
+            jobRoutes.remove = createRemoveProcedure(job, operations.remove, shared);
+        }
+        // Create router for this job (named by job name)
+        routes[jobName] = createRouter({ routes: jobRoutes });
+    }
+    // Return router containing all job routers
+    return createRouter({ routes });
+}
+//# sourceMappingURL=router.js.map