sidekiq-ts 1.0.0

package/dist/cli-helpers.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from "./config.js";
+export declare const DEFAULT_CONFIG_PATH = "sidekiq.json";
+export interface CliOptions {
+    configPath: string;
+    configPathProvided: boolean;
+    concurrency?: number;
+    environment?: string;
+    queues?: string[];
+    requirePaths?: string[];
+    tag?: string;
+    timeout?: number;
+    verbose: boolean;
+    showHelp: boolean;
+    showVersion: boolean;
+}
+export declare const parseArgs: (argv: string[]) => CliOptions;
+export declare const resolveEnvironment: (cliEnv?: string) => string | undefined;
+export declare const applyCliOptions: (config: Config, options: CliOptions, loadedRequirePaths?: string[]) => {
+    config: Config;
+    requirePaths: string[];
+};
+//# sourceMappingURL=cli-helpers.d.ts.map

package/dist/cli-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-helpers.d.ts","sourceRoot":"","sources":["../src/cli-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAElD,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;CACtB;AAWD,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UAiH1C,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,SAKvC,CAAC;AASxB,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,EACd,SAAS,UAAU,EACnB,qBAAoB,MAAM,EAAO,KAChC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAuB1C,CAAC"}

package/dist/cli-helpers.js

@@ -0,0 +1,152 @@
+export const DEFAULT_CONFIG_PATH = "sidekiq.json";
+const parseNumber = (value, flag) => {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${flag} expects a positive number`);
+    }
+    return parsed;
+};
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: CLI argument parsing is inherently complex
+export const parseArgs = (argv) => {
+    const args = argv.slice(2);
+    const options = {
+        configPath: DEFAULT_CONFIG_PATH,
+        configPathProvided: false,
+        verbose: false,
+        showHelp: false,
+        showVersion: false,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const raw = args[i];
+        const [arg, inlineValue] = raw.startsWith("--") && raw.includes("=")
+            ? raw.split("=", 2)
+            : [raw, undefined];
+        const value = inlineValue ?? args[i + 1];
+        switch (arg) {
+            case "-h":
+            case "--help":
+                options.showHelp = true;
+                break;
+            case "-V":
+            case "--version":
+                options.showVersion = true;
+                break;
+            case "-C":
+            case "--config":
+                if (!value) {
+                    throw new Error(`${arg} expects a path`);
+                }
+                options.configPath = value;
+                options.configPathProvided = true;
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-c":
+            case "--concurrency":
+                if (!value) {
+                    throw new Error(`${arg} expects a number`);
+                }
+                options.concurrency = parseNumber(value, arg);
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-e":
+            case "--environment":
+                if (!value) {
+                    throw new Error(`${arg} expects a value`);
+                }
+                options.environment = value;
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-g":
+            case "--tag":
+                if (!value) {
+                    throw new Error(`${arg} expects a value`);
+                }
+                options.tag = value;
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-q":
+            case "--queue":
+                if (!value) {
+                    throw new Error(`${arg} expects a queue name`);
+                }
+                options.queues ??= [];
+                options.queues.push(value);
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-r":
+            case "--require":
+                if (!value) {
+                    throw new Error(`${arg} expects a path`);
+                }
+                options.requirePaths ??= [];
+                options.requirePaths.push(value);
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-t":
+            case "--timeout":
+                if (!value) {
+                    throw new Error(`${arg} expects a number`);
+                }
+                options.timeout = parseNumber(value, arg);
+                if (!inlineValue) {
+                    i += 1;
+                }
+                break;
+            case "-v":
+            case "--verbose":
+                options.verbose = true;
+                break;
+            default:
+                if (arg.startsWith("-")) {
+                    throw new Error(`Unknown option ${arg}`);
+                }
+                break;
+        }
+    }
+    return options;
+};
+export const resolveEnvironment = (cliEnv) => cliEnv ??
+    process.env.APP_ENV ??
+    process.env.NODE_ENV ??
+    process.env.RACK_ENV ??
+    process.env.RAILS_ENV;
+const suppressDebug = (logger) => ({
+    debug: () => undefined,
+    info: logger.info.bind(logger),
+    warn: logger.warn.bind(logger),
+    error: logger.error.bind(logger),
+});
+export const applyCliOptions = (config, options, loadedRequirePaths = []) => {
+    let requirePaths = loadedRequirePaths;
+    if (options.concurrency !== undefined) {
+        config.concurrency = options.concurrency;
+    }
+    if (options.queues && options.queues.length > 0) {
+        config.queues = options.queues;
+    }
+    if (options.tag) {
+        config.tag = options.tag;
+    }
+    if (options.timeout !== undefined) {
+        config.timeout = options.timeout;
+    }
+    if (!options.verbose) {
+        config.logger = suppressDebug(config.logger);
+    }
+    if (options.requirePaths && options.requirePaths.length > 0) {
+        requirePaths = options.requirePaths;
+    }
+    return { config, requirePaths };
+};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { access } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { applyCliOptions, parseArgs, resolveEnvironment, } from "./cli-helpers.js";
+import { Config } from "./config.js";
+import { loadConfigFile } from "./config-loader.js";
+import { Sidekiq } from "./sidekiq.js";
+const printHelp = () => {
+    console.log(`Usage: sidekiq-ts [options]
+
+Options:
+  -C, --config PATH       Path to JSON config file (default: sidekiq.json if present)
+  -c, --concurrency NUM   Processor threads to use
+  -e, --environment ENV   Application environment
+  -g, --tag TAG           Process tag
+  -q, --queue QUEUE[,WT]  Queue with optional weight (repeatable)
+  -r, --require PATH      File or directory to import before startup (repeatable)
+  -t, --timeout NUM       Shutdown timeout seconds
+  -v, --verbose           Enable debug logging
+  -V, --version           Print version and exit
+  -h, --help              Show this help message
+`);
+};
+const fileExists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const printVersion = () => {
+    const require = createRequire(import.meta.url);
+    const pkg = require("../package.json");
+    const name = pkg.name ?? "sidekiq-ts";
+    const version = pkg.version ?? "0.0.0";
+    console.log(`${name} ${version}`);
+};
+const registerSignal = (signal, handler) => {
+    try {
+        process.on(signal, () => {
+            Promise.resolve(handler()).catch(() => undefined);
+        });
+    }
+    catch {
+        // Signal not supported on this platform.
+    }
+};
+const main = async () => {
+    const options = parseArgs(process.argv);
+    if (options.showHelp) {
+        printHelp();
+        return;
+    }
+    if (options.showVersion) {
+        printVersion();
+        return;
+    }
+    const environment = resolveEnvironment(options.environment);
+    if (environment && !process.env.NODE_ENV) {
+        process.env.NODE_ENV = environment;
+    }
+    let config = new Config();
+    let requirePaths = [];
+    const configExists = await fileExists(options.configPath);
+    if (options.configPathProvided || configExists) {
+        if (!configExists) {
+            throw new Error(`No such file ${options.configPath}`);
+        }
+        const loaded = await loadConfigFile(options.configPath, { environment });
+        config = loaded.config;
+        requirePaths = loaded.requirePaths;
+    }
+    ({ config, requirePaths } = applyCliOptions(config, options, requirePaths));
+    for (const entry of requirePaths) {
+        const fullPath = resolve(entry);
+        await import(pathToFileURL(fullPath).href);
+    }
+    const runner = await Sidekiq.run({ config });
+    let shuttingDown = false;
+    let quieting = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        config.logger.info(() => `Received ${signal}, shutting down`);
+        await runner.stop();
+        process.exit(0);
+    };
+    const quiet = async (signal) => {
+        if (quieting) {
+            return;
+        }
+        quieting = true;
+        config.logger.info(() => `Received ${signal}, no longer accepting new work`);
+        await runner.quiet();
+    };
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: signal handling needs detailed logging
+    const dumpState = (signal) => {
+        config.logger.warn(() => `Received ${signal}, dumping state`);
+        const snapshot = runner.snapshotWork();
+        if (snapshot.length === 0) {
+            config.logger.warn(() => "No active jobs");
+        }
+        else {
+            config.logger.warn(() => `Active jobs: ${snapshot.length}`);
+            for (const entry of snapshot) {
+                const payload = entry.payload;
+                let className;
+                if (!payload) {
+                    className = "unknown";
+                }
+                else if (typeof payload.class === "string") {
+                    className = payload.class;
+                }
+                else {
+                    className = payload.class?.name ?? String(payload.class);
+                }
+                const jid = payload?.jid ?? "unknown";
+                const elapsed = entry.elapsed.toFixed(3);
+                config.logger.warn(() => `Worker ${entry.workerId} class=${className} jid=${jid} queue=${entry.queue} elapsed=${elapsed}s`);
+            }
+        }
+        const stack = new Error("Signal stack").stack;
+        if (stack) {
+            const lines = stack.split("\n").slice(1).join("\n");
+            config.logger.warn(() => `Current stack:\n${lines}`);
+        }
+    };
+    registerSignal("SIGINT", () => shutdown("SIGINT"));
+    registerSignal("SIGTERM", () => shutdown("SIGTERM"));
+    registerSignal("SIGTSTP", () => quiet("SIGTSTP"));
+    registerSignal("SIGTTIN", () => dumpState("SIGTTIN"));
+    registerSignal("SIGINFO", () => dumpState("SIGINFO"));
+};
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+import type { Config } from "./config.js";
+import type { RedisClient } from "./redis.js";
+import type { BulkPayload, JobClassLike, JobPayload } from "./types.js";
+export declare class Client {
+    private readonly config;
+    private readonly redisClient?;
+    constructor({ config, redis, }?: {
+        config?: Config;
+        redis?: RedisClient;
+    });
+    private getRedis;
+    middleware(fn?: (chain: Config["clientMiddleware"]) => void): Config["clientMiddleware"];
+    push(item: JobPayload): Promise<string | null>;
+    pushBulk(items: BulkPayload): Promise<(string | null)[]>;
+    cancel(jid: string): Promise<boolean>;
+    static push(item: JobPayload): Promise<string | null>;
+    static pushBulk(items: BulkPayload): Promise<(string | null)[]>;
+    static enqueue<TArgs extends unknown[]>(klass: JobClassLike, ...args: TArgs): Promise<string | null>;
+    static enqueueTo<TArgs extends unknown[]>(queue: string, klass: JobClassLike, ...args: TArgs): Promise<string | null>;
+    static enqueueToIn<TArgs extends unknown[]>(queue: string, interval: number, klass: JobClassLike, ...args: TArgs): Promise<string | null>;
+    static enqueueIn<TArgs extends unknown[]>(interval: number, klass: JobClassLike, ...args: TArgs): Promise<string | null>;
+    static via<T>(redis: RedisClient, fn: () => Promise<T>): Promise<T>;
+    private rawPush;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAS1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIxE,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAc;gBAE/B,EACV,MAAM,EACN,KAAK,GACN,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,WAAW,CAAA;KAAO;YAKlC,QAAQ;IAQtB,UAAU,CACR,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,kBAAkB,CAAC,KAAK,IAAI,GAC/C,MAAM,CAAC,kBAAkB,CAAC;IAOvB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqB9C,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IA0GxD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc3C,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIrD,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAI/D,MAAM,CAAC,OAAO,CAAC,KAAK,SAAS,OAAO,EAAE,EACpC,KAAK,EAAE,YAAY,EACnB,GAAG,IAAI,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzB,MAAM,CAAC,SAAS,CAAC,KAAK,SAAS,OAAO,EAAE,EACtC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,EACnB,GAAG,IAAI,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzB,MAAM,CAAC,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE,EACxC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,EACnB,GAAG,IAAI,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAUzB,MAAM,CAAC,SAAS,CAAC,KAAK,SAAS,OAAO,EAAE,EACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,YAAY,EACnB,GAAG,IAAI,EAAE,KAAK,GACb,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQzB,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;YAKrD,OAAO;CAoDtB"}

package/dist/client.js

@@ -0,0 +1,212 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ITERATION_STATE_TTL_SECONDS } from "./iterable-constants.js";
+import { generateJid, normalizeItem, nowInMillis, verifyJson, } from "./job-util.js";
+import { dumpJson } from "./json.js";
+import { Sidekiq } from "./sidekiq.js";
+import { Testing } from "./testing.js";
+const redisContext = new AsyncLocalStorage();
+export class Client {
+    config;
+    redisClient;
+    constructor({ config, redis, } = {}) {
+        this.config = config ?? Sidekiq.defaultConfiguration;
+        this.redisClient = redis;
+    }
+    async getRedis() {
+        return (this.redisClient ??
+            redisContext.getStore() ??
+            (await this.config.getRedisClient()));
+    }
+    middleware(fn) {
+        if (fn) {
+            fn(this.config.clientMiddleware);
+        }
+        return this.config.clientMiddleware;
+    }
+    async push(item) {
+        const normalized = normalizeItem(item, Sidekiq.defaultJobOptions());
+        const queue = normalized.queue ?? "default";
+        const redis = await this.getRedis();
+        const result = await this.config.clientMiddleware.invoke(item.class, normalized, queue, redis, async () => normalized);
+        if (!result) {
+            return null;
+        }
+        const payload = result;
+        verifyJson(payload.args, this.config.strictArgs);
+        await this.rawPush([payload]);
+        return payload.jid ?? null;
+    }
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: bulk push validation is inherently complex
+    async pushBulk(items) {
+        const batchSize = items.batch_size ?? 1000;
+        const args = items.args;
+        const at = items.at;
+        if (!Array.isArray(args)) {
+            throw new Error("Bulk arguments must be an Array of Arrays");
+        }
+        if (at !== undefined) {
+            const atArray = Array.isArray(at) ? at : [at];
+            if (atArray.length === 0 ||
+                !atArray.every((entry) => typeof entry === "number")) {
+                throw new Error("Job 'at' must be a number or array of numbers");
+            }
+            if (Array.isArray(at) && at.length !== args.length) {
+                throw new Error("Job 'at' array must match args array size");
+            }
+        }
+        const jid = items.jid;
+        if (jid && args.length > 1) {
+            throw new Error("Explicit 'jid' is not supported for bulk jobs");
+        }
+        const spreadInterval = items.spread_interval;
+        if (spreadInterval !== undefined &&
+            (typeof spreadInterval !== "number" || spreadInterval <= 0)) {
+            throw new Error("Jobs 'spread_interval' must be a positive number");
+        }
+        if (at !== undefined && spreadInterval !== undefined) {
+            throw new Error("Only one of 'at' or 'spread_interval' can be provided");
+        }
+        let resolvedAt = at;
+        if (resolvedAt === undefined && spreadInterval !== undefined) {
+            const interval = Math.max(spreadInterval, 5);
+            const now = Date.now() / 1000;
+            resolvedAt = args.map(() => now + Math.random() * interval);
+        }
+        const base = {
+            ...items,
+            args,
+        };
+        base.batch_size = undefined;
+        base.spread_interval = undefined;
+        base.at = undefined;
+        base.jid = undefined;
+        const normalized = normalizeItem(base, Sidekiq.defaultJobOptions());
+        const results = [];
+        const redis = await this.getRedis();
+        for (let i = 0; i < args.length; i += batchSize) {
+            const slice = args.slice(i, i + batchSize);
+            if (slice.length === 0) {
+                break;
+            }
+            if (!slice.every((entry) => Array.isArray(entry))) {
+                throw new Error("Bulk arguments must be an Array of Arrays: [[1], [2]]");
+            }
+            const payloads = await Promise.all(slice.map(async (jobArgs, index) => {
+                const payload = {
+                    ...normalized,
+                    args: jobArgs,
+                    jid: generateJid(),
+                };
+                if (resolvedAt !== undefined) {
+                    payload.at = Array.isArray(resolvedAt)
+                        ? resolvedAt[i + index]
+                        : resolvedAt;
+                }
+                const result = await this.config.clientMiddleware.invoke(items.class, payload, payload.queue ?? "default", redis, async () => payload);
+                if (!result) {
+                    return null;
+                }
+                const finalPayload = result;
+                verifyJson(finalPayload.args, this.config.strictArgs);
+                return finalPayload;
+            }));
+            const toPush = payloads.filter((payload) => Boolean(payload));
+            await this.rawPush(toPush);
+            results.push(...payloads.map((payload) => payload?.jid ?? null));
+        }
+        return results;
+    }
+    async cancel(jid) {
+        const redis = await this.getRedis();
+        const key = `it-${jid}`;
+        const now = String(Math.floor(Date.now() / 1000));
+        const pipeline = redis.multi();
+        pipeline.hSetNX(key, "cancelled", now);
+        pipeline.hGet(key, "cancelled");
+        pipeline.expire(key, ITERATION_STATE_TTL_SECONDS, "NX");
+        const result = await pipeline.exec();
+        const cancelled = result?.[1];
+        return Boolean(Number(cancelled));
+    }
+    // biome-ignore lint/suspicious/useAdjacentOverloadSignatures: static methods are grouped separately from instance methods
+    static push(item) {
+        return new Client().push(item);
+    }
+    static pushBulk(items) {
+        return new Client().pushBulk(items);
+    }
+    static enqueue(klass, ...args) {
+        return Client.push({ class: klass, args });
+    }
+    static enqueueTo(queue, klass, ...args) {
+        return Client.push({ class: klass, queue, args });
+    }
+    static enqueueToIn(queue, interval, klass, ...args) {
+        const now = Date.now() / 1000;
+        const ts = interval < 1_000_000_000 ? now + interval : interval;
+        const payload = { class: klass, queue, args };
+        if (ts > now) {
+            payload.at = ts;
+        }
+        return Client.push(payload);
+    }
+    static enqueueIn(interval, klass, ...args) {
+        const queue = typeof klass !== "string" && klass.getSidekiqOptions
+            ? (klass.getSidekiqOptions().queue ?? "default")
+            : "default";
+        return Client.enqueueToIn(queue, interval, klass, ...args);
+    }
+    static via(redis, fn) {
+        return redisContext.run(redis, fn);
+    }
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: push logic requires handling multiple cases
+    async rawPush(payloads) {
+        if (payloads.length === 0) {
+            return;
+        }
+        const testMode = Testing.mode();
+        if (testMode === "fake") {
+            for (const payload of payloads) {
+                Testing.enqueue(payload);
+            }
+            return;
+        }
+        if (testMode === "inline") {
+            for (const payload of payloads) {
+                await Testing.performInline(payload, this.config);
+            }
+            return;
+        }
+        const redis = await this.getRedis();
+        const pipeline = redis.multi();
+        if (payloads[0].at !== undefined) {
+            for (const payload of payloads) {
+                const at = payload.at;
+                const { at: _at, enqueued_at: _enqueuedAt, ...copy } = payload;
+                pipeline.zAdd("schedule", [{ score: at, value: dumpJson(copy) }]);
+            }
+        }
+        else {
+            const now = nowInMillis();
+            const grouped = new Map();
+            for (const payload of payloads) {
+                const queue = payload.queue;
+                const bucket = grouped.get(queue) ?? [];
+                bucket.push(payload);
+                grouped.set(queue, bucket);
+            }
+            const queueNames = Array.from(grouped.keys());
+            if (queueNames.length > 0) {
+                pipeline.sAdd("queues", queueNames);
+            }
+            for (const [queue, entries] of grouped.entries()) {
+                const toPush = entries.map((entry) => {
+                    entry.enqueued_at = now;
+                    return dumpJson(entry);
+                });
+                pipeline.lPush(`queue:${queue}`, toPush);
+            }
+        }
+        await pipeline.exec();
+    }
+}

package/dist/config-loader.d.ts

@@ -0,0 +1,16 @@
+import { Config } from "./config.js";
+import type { ConfigOptions } from "./types.js";
+export interface JsonConfig extends ConfigOptions {
+    require?: string | string[];
+    environments?: Record<string, JsonConfig>;
+}
+export interface LoadedConfig {
+    config: Config;
+    requirePaths: string[];
+    sourcePath: string;
+}
+export interface LoadConfigOptions {
+    environment?: string;
+}
+export declare const loadConfigFile: (path: string, options?: LoadConfigOptions) => Promise<LoadedConfig>;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../src/config-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA4BD,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,UAAS,iBAAsB,KAC9B,OAAO,CAAC,YAAY,CActB,CAAC"}

package/dist/config-loader.js

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Config } from "./config.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const normalizeRequire = (value) => {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string");
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    return [];
+};
+const resolveEnvironmentOverrides = (parsed, environment) => {
+    if (!environment) {
+        return {};
+    }
+    const direct = isRecord(parsed[environment]) ? parsed[environment] : {};
+    const envMap = isRecord(parsed.environments) ? parsed.environments : {};
+    const mapped = isRecord(envMap[environment]) ? envMap[environment] : {};
+    return { ...direct, ...mapped };
+};
+export const loadConfigFile = async (path, options = {}) => {
+    const fullPath = resolve(path);
+    const raw = await readFile(fullPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const envOverrides = resolveEnvironmentOverrides(parsed, options.environment);
+    const merged = { ...parsed, ...envOverrides };
+    const requirePaths = normalizeRequire(merged.require);
+    merged.require = undefined;
+    merged.environments = undefined;
+    if (options.environment) {
+        merged[options.environment] = undefined;
+    }
+    const config = new Config(merged);
+    return { config, requirePaths, sourcePath: fullPath };
+};