@zintrust/core 0.1.41 → 0.1.43

package/src/scheduler/cron/Cron.js

@@ -0,0 +1,200 @@
+const ANY = Object.freeze({ any: true });
+const toInt = (value) => {
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : null;
+};
+const clamp = (n, range) => Math.min(range.max, Math.max(range.min, n));
+const expandStep = (step, range, out) => {
+    for (let i = range.min; i <= range.max; i += step)
+        out.add(i);
+};
+const expandRange = (trimmed, range, out) => {
+    const left = trimmed.slice(0, trimmed.indexOf('-'));
+    const rest = trimmed.slice(trimmed.indexOf('-') + 1);
+    const slashIdx = rest.indexOf('/');
+    const right = slashIdx === -1 ? rest : rest.slice(0, slashIdx);
+    const stepRaw = slashIdx === -1 ? null : rest.slice(slashIdx + 1);
+    const start = toInt(left);
+    const end = toInt(right);
+    const step = stepRaw === null ? 1 : toInt(stepRaw);
+    if (start === null || end === null || step === null || step <= 0)
+        return;
+    const a = clamp(start, range);
+    const b = clamp(end, range);
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    for (let i = lo; i <= hi; i += step)
+        out.add(i);
+};
+const expandPart = (part, range, out) => {
+    const trimmed = part.trim();
+    if (trimmed.length === 0)
+        return;
+    if (trimmed.startsWith('*/')) {
+        const step = toInt(trimmed.slice(2));
+        if (step !== null && step > 0)
+            expandStep(step, range, out);
+        return;
+    }
+    if (trimmed.includes('-')) {
+        expandRange(trimmed, range, out);
+        return;
+    }
+    const num = toInt(trimmed);
+    if (num !== null)
+        out.add(clamp(num, range));
+};
+const parseField = (raw, range, normalize) => {
+    const value = raw.trim();
+    if (value === '*' || value.length === 0)
+        return ANY;
+    const set = new Set();
+    for (const part of value.split(',')) {
+        expandPart(part, range, set);
+    }
+    if (normalize !== undefined) {
+        const normalized = new Set();
+        for (const n of set)
+            normalized.add(normalize(n));
+        return Object.freeze({ any: false, values: normalized });
+    }
+    return Object.freeze({ any: false, values: set });
+};
+const matches = (allowed, value) => {
+    if (allowed.any)
+        return true;
+    return allowed.values.has(value);
+};
+const weekdayToDow = (weekdayShort) => {
+    switch (weekdayShort) {
+        case 'Sun':
+            return 0;
+        case 'Mon':
+            return 1;
+        case 'Tue':
+            return 2;
+        case 'Wed':
+            return 3;
+        case 'Thu':
+            return 4;
+        case 'Fri':
+            return 5;
+        case 'Sat':
+            return 6;
+        default:
+            return 0;
+    }
+};
+const dtfCache = new Map();
+const getFormatter = (timeZone) => {
+    const key = `en-US|${timeZone}`;
+    const cached = dtfCache.get(key);
+    if (cached)
+        return cached;
+    const fmt = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        weekday: 'short',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23',
+    });
+    dtfCache.set(key, fmt);
+    return fmt;
+};
+const getZonedParts = (date, timeZone) => {
+    // Fallback to UTC if Intl timeZone support is unavailable.
+    try {
+        const fmt = getFormatter(timeZone);
+        const parts = fmt.formatToParts(date);
+        const get = (type) => parts.find((p) => p.type === type)?.value;
+        const minute = Number.parseInt(get('minute') ?? '0', 10);
+        const hour = Number.parseInt(get('hour') ?? '0', 10);
+        const day = Number.parseInt(get('day') ?? '1', 10);
+        const month = Number.parseInt(get('month') ?? '1', 10);
+        const weekday = get('weekday') ?? 'Sun';
+        const dow = weekdayToDow(weekday);
+        return { minute, hour, day, month, dow };
+    }
+    catch {
+        return {
+            minute: date.getUTCMinutes(),
+            hour: date.getUTCHours(),
+            day: date.getUTCDate(),
+            month: date.getUTCMonth() + 1,
+            dow: date.getUTCDay(),
+        };
+    }
+};
+const domDowMatches = (spec, parts) => {
+    const domAny = spec.dayOfMonth.any;
+    const dowAny = spec.dayOfWeek.any;
+    const domOk = matches(spec.dayOfMonth, parts.day);
+    const dowOk = matches(spec.dayOfWeek, parts.dow);
+    // Vixie cron semantics:
+    // - if either DOM or DOW is '*', require the other field to match
+    // - if both are restricted, match if either matches
+    if (domAny && dowAny)
+        return true;
+    if (domAny)
+        return dowOk;
+    if (dowAny)
+        return domOk;
+    return domOk || dowOk;
+};
+const matchesSpec = (spec, parts) => {
+    return (matches(spec.minute, parts.minute) &&
+        matches(spec.hour, parts.hour) &&
+        matches(spec.month, parts.month) &&
+        domDowMatches(spec, parts));
+};
+export const Cron = Object.freeze({
+    parse(expr) {
+        const raw = String(expr ?? '').trim();
+        const parts = raw.split(/\s+/).filter(Boolean);
+        if (parts.length !== 5) {
+            // Return an "any" spec for invalid inputs; runner will treat it as "every minute".
+            return Object.freeze({
+                minute: ANY,
+                hour: ANY,
+                dayOfMonth: ANY,
+                month: ANY,
+                dayOfWeek: ANY,
+            });
+        }
+        const [min, hour, dom, month, dow] = parts;
+        const normalizeDow = (n) => {
+            // allow 7 as Sunday
+            if (n === 7)
+                return 0;
+            return clamp(n, { min: 0, max: 6 });
+        };
+        return Object.freeze({
+            minute: parseField(min, { min: 0, max: 59 }),
+            hour: parseField(hour, { min: 0, max: 23 }),
+            dayOfMonth: parseField(dom, { min: 1, max: 31 }),
+            month: parseField(month, { min: 1, max: 12 }),
+            dayOfWeek: parseField(dow, { min: 0, max: 7 }, normalizeDow),
+        });
+    },
+    nextRunAtMs(nowMs, expr, timeZone = 'UTC') {
+        const spec = this.parse(expr);
+        const base = new Date(nowMs);
+        // Cron is minute-resolution; start from next minute boundary.
+        base.setUTCSeconds(0, 0);
+        base.setTime(base.getTime() + 60_000);
+        // Bound search to 366 days (minute granularity). This is defensive; typical crons resolve quickly.
+        const maxIterations = 366 * 24 * 60;
+        for (let i = 0; i < maxIterations; i++) {
+            const parts = getZonedParts(base, timeZone);
+            if (matchesSpec(spec, parts))
+                return base.getTime();
+            base.setTime(base.getTime() + 60_000);
+        }
+        // Fallback: run in 60s.
+        return nowMs + 60_000;
+    },
+});
+export default Cron;

package/src/scheduler/leader/SchedulerLeader.d.ts

@@ -0,0 +1,14 @@
+export type SchedulerLeaderHooks = Readonly<{
+    onBecameLeader: () => void;
+    onLostLeadership: () => void;
+}>;
+export type SchedulerLeaderApi = Readonly<{
+    isEnabled: () => boolean;
+    start: (hooks: SchedulerLeaderHooks) => void;
+    stop: () => Promise<void>;
+}>;
+export declare const SchedulerLeader: Readonly<{
+    create(): SchedulerLeaderApi;
+}>;
+export default SchedulerLeader;
+//# sourceMappingURL=SchedulerLeader.d.ts.map

package/src/scheduler/leader/SchedulerLeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchedulerLeader.d.ts","sourceRoot":"","sources":["../../../../src/scheduler/leader/SchedulerLeader.ts"],"names":[],"mappings":"AAoFA,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,gBAAgB,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,KAAK,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC7C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC,CAAC;AAgGH,eAAO,MAAM,eAAe;cAChB,kBAAkB;EAkD5B,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/scheduler/leader/SchedulerLeader.js

@@ -0,0 +1,187 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ZintrustLang } from '../../lang/lang.js';
+import { createAdvancedQueue } from '../../tools/queue/AdvancedQueue.js';
+import { getLockProvider } from '../../tools/queue/LockProvider.js';
+const readSettings = () => {
+    const enabled = Env.getBool('SCHEDULE_LEADER_ENABLED', false);
+    const provider = Env.get('SCHEDULE_LEADER_LOCK_PROVIDER', 'memory').trim() || 'memory';
+    const key = Env.get('SCHEDULE_LEADER_LOCK_KEY', 'scheduler:leader').trim() || 'scheduler:leader';
+    const ttlMs = Env.getInt('SCHEDULE_LEADER_LOCK_TTL_MS', 30000);
+    const renewEveryMs = Env.getInt('SCHEDULE_LEADER_LOCK_RENEW_MS', Math.floor(ttlMs / 2));
+    const retryEveryMs = Env.getInt('SCHEDULE_LEADER_LOCK_RETRY_MS', 5000);
+    const acquireTimeoutMs = Env.getInt('SCHEDULE_LEADER_LOCK_ACQUIRE_TIMEOUT_MS', 2000);
+    return Object.freeze({
+        enabled,
+        provider,
+        key,
+        ttlMs: Math.max(1000, ttlMs),
+        renewEveryMs: Math.max(250, renewEveryMs),
+        retryEveryMs: Math.max(250, retryEveryMs),
+        acquireTimeoutMs: Math.max(250, acquireTimeoutMs),
+    });
+};
+const isUnrefableTimer = (timer) => {
+    return (typeof timer === 'object' &&
+        timer !== null &&
+        'unref' in timer &&
+        typeof timer.unref === 'function');
+};
+const withTimeout = async (promise, timeoutMs) => {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return promise;
+    let timeoutId;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeoutId = globalThis.setTimeout(() => {
+                    reject(ErrorFactory.createConnectionError('Leader lock acquire timed out', { timeoutMs }));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId !== undefined)
+            globalThis.clearTimeout(timeoutId);
+    }
+};
+const resolveProvider = (providerName, ttlMs) => {
+    const name = providerName.trim().toLowerCase();
+    if (name.length === 0)
+        return null;
+    // Ensure provider is registered; AdvancedQueue wiring bootstraps lock providers.
+    createAdvancedQueue({
+        name: ZintrustLang.CLI_LOCKS,
+        connection: undefined,
+        defaultDedupTtl: ttlMs,
+        lockProvider: name,
+    });
+    return getLockProvider(name) ?? null;
+};
+const clearTimers = (state) => {
+    if (state.renewTimer !== undefined) {
+        globalThis.clearInterval(state.renewTimer);
+        state.renewTimer = undefined;
+    }
+    if (state.retryTimer !== undefined) {
+        globalThis.clearInterval(state.retryTimer);
+        state.retryTimer = undefined;
+    }
+};
+const loseLeadership = (state) => {
+    if (state.leaderLock !== null) {
+        Logger.warn('Scheduler leadership lost; stopping schedules');
+    }
+    state.leaderLock = null;
+    state.hooks?.onLostLeadership();
+};
+const ensureProvider = (state, settings) => {
+    if (state.provider !== null)
+        return state.provider;
+    state.provider = resolveProvider(settings.provider, settings.ttlMs);
+    if (state.provider === null) {
+        Logger.warn('Leader lock provider not available; scheduling disabled', {
+            provider: settings.provider,
+        });
+    }
+    return state.provider;
+};
+const tryAcquire = async (state, settings) => {
+    if (!state.started)
+        return;
+    if (state.leaderLock !== null)
+        return;
+    const provider = ensureProvider(state, settings);
+    if (provider === null)
+        return;
+    try {
+        const lock = await withTimeout(provider.acquire(settings.key, { ttl: settings.ttlMs }), settings.acquireTimeoutMs);
+        if (!lock.acquired)
+            return;
+        state.leaderLock = lock;
+        Logger.info('Scheduler leadership acquired', { key: settings.key, ttlMs: settings.ttlMs });
+        state.hooks?.onBecameLeader();
+    }
+    catch (error) {
+        Logger.warn('Failed to acquire scheduler leader lock', {
+            key: settings.key,
+            provider: settings.provider,
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+const startRenewLoop = (state, settings) => {
+    if (state.renewTimer !== undefined)
+        return;
+    state.renewTimer = globalThis.setInterval(async () => {
+        if (!state.started)
+            return;
+        if (state.leaderLock === null || state.provider === null)
+            return;
+        const ok = await state.provider.extend(state.leaderLock, settings.ttlMs);
+        if (!ok)
+            loseLeadership(state);
+    }, settings.renewEveryMs);
+    if (isUnrefableTimer(state.renewTimer))
+        state.renewTimer.unref();
+};
+const startRetryLoop = (state, settings) => {
+    if (state.retryTimer !== undefined)
+        return;
+    state.retryTimer = globalThis.setInterval(() => {
+        void tryAcquire(state, settings);
+    }, settings.retryEveryMs);
+    if (isUnrefableTimer(state.retryTimer))
+        state.retryTimer.unref();
+};
+export const SchedulerLeader = Object.freeze({
+    create() {
+        const state = {
+            started: false,
+            leaderLock: null,
+            provider: null,
+            renewTimer: undefined,
+            retryTimer: undefined,
+            hooks: null,
+        };
+        return Object.freeze({
+            isEnabled() {
+                return readSettings().enabled;
+            },
+            start(newHooks) {
+                const settings = readSettings();
+                if (!settings.enabled)
+                    return;
+                if (state.started)
+                    return;
+                state.started = true;
+                state.hooks = newHooks;
+                state.provider = null;
+                // Attempt immediately; keep retrying until acquired.
+                void tryAcquire(state, settings);
+                startRetryLoop(state, settings);
+                startRenewLoop(state, settings);
+            },
+            async stop() {
+                if (!state.started)
+                    return;
+                state.started = false;
+                clearTimers(state);
+                if (state.leaderLock !== null && state.provider !== null) {
+                    try {
+                        await state.provider.release(state.leaderLock);
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                state.leaderLock = null;
+                state.provider = null;
+                state.hooks = null;
+            },
+        });
+    },
+});
+export default SchedulerLeader;

package/src/scheduler/state/ScheduleStateStore.d.ts

@@ -0,0 +1,27 @@
+export type ScheduleRunState = Readonly<{
+    lastRunAt?: number;
+    lastSuccessAt?: number;
+    lastErrorAt?: number;
+    lastErrorMessage?: string;
+    nextRunAt?: number;
+    consecutiveFailures?: number;
+}>;
+export type ScheduleRunStatePatch = Partial<ScheduleRunState>;
+export type IScheduleStateStore = Readonly<{
+    get: (name: string) => Promise<ScheduleRunState | null>;
+    set: (name: string, patch: ScheduleRunStatePatch) => Promise<void>;
+    list: () => Promise<Array<{
+        name: string;
+        state: ScheduleRunState;
+    }>>;
+}>;
+export declare const InMemoryScheduleStateStore: Readonly<{
+    create(): IScheduleStateStore;
+}>;
+declare const _default: {
+    InMemoryScheduleStateStore: Readonly<{
+        create(): IScheduleStateStore;
+    }>;
+};
+export default _default;
+//# sourceMappingURL=ScheduleStateStore.d.ts.map

package/src/scheduler/state/ScheduleStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleStateStore.d.ts","sourceRoot":"","sources":["../../../../src/scheduler/state/ScheduleStateStore.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAE9D,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IACxD,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,IAAI,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,gBAAgB,CAAA;KAAE,CAAC,CAAC,CAAC;CACvE,CAAC,CAAC;AAIH,eAAO,MAAM,0BAA0B;cAC3B,mBAAmB;EAuB7B,CAAC;;;kBAvBS,mBAAmB;;;AAyB/B,wBAEE"}

package/src/scheduler/state/ScheduleStateStore.js

@@ -0,0 +1,27 @@
+const normalizeName = (name) => String(name ?? '').trim();
+export const InMemoryScheduleStateStore = Object.freeze({
+    create() {
+        const states = new Map();
+        return Object.freeze({
+            async get(name) {
+                const key = normalizeName(name);
+                if (key.length === 0)
+                    return null;
+                return states.get(key) ?? null;
+            },
+            async set(name, patch) {
+                const key = normalizeName(name);
+                if (key.length === 0)
+                    return;
+                const current = states.get(key) ?? {};
+                states.set(key, { ...current, ...patch });
+            },
+            async list() {
+                return Array.from(states.entries()).map(([name, state]) => ({ name, state }));
+            },
+        });
+    },
+});
+export default {
+    InMemoryScheduleStateStore,
+};

package/src/scheduler/types.d.ts

@@ -6,9 +6,19 @@ export type IScheduleKernel = Readonly<{
     getRouter?: () => unknown;
 }>;
 export type IScheduleHandler = (kernel?: IScheduleKernel) => Promise<void> | void;
+export type IScheduleBackoffPolicy = Readonly<{
+    initialMs: number;
+    maxMs: number;
+    factor?: number;
+}>;
 export type ISchedule = {
     name: string;
     intervalMs?: number;
+    cron?: string;
+    timezone?: string;
+    jitterMs?: number;
+    backoff?: IScheduleBackoffPolicy;
+    leaderOnly?: boolean;
     handler: IScheduleHandler;
     enabled?: boolean;
     runOnStart?: boolean;

package/src/scheduler/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/scheduler/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAElF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/scheduler/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAElF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/src/schedules/index.d.ts

@@ -1,2 +1,3 @@
+export { default as jobTrackingCleanup } from './job-tracking-cleanup';
 export { default as logCleanup } from './log-cleanup';
 //# sourceMappingURL=index.d.ts.map

package/src/schedules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schedules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schedules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,wBAAwB,CAAC"}

package/src/schedules/index.js

@@ -1 +1,2 @@
+export { default as jobTrackingCleanup } from './job-tracking-cleanup.js';
 export { default as logCleanup } from './log-cleanup.js';

package/src/schedules/job-tracking-cleanup.d.ts

@@ -0,0 +1,4 @@
+export declare const cleanupJobTrackingOnce: () => Promise<void>;
+declare const JobTrackingCleanupSchedule: import("../scheduler").ISchedule;
+export default JobTrackingCleanupSchedule;
+//# sourceMappingURL=job-tracking-cleanup.d.ts.map

package/src/schedules/job-tracking-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-tracking-cleanup.d.ts","sourceRoot":"","sources":["../../../src/schedules/job-tracking-cleanup.ts"],"names":[],"mappings":"AA4FA,eAAO,MAAM,sBAAsB,QAAa,OAAO,CAAC,IAAI,CAS3D,CAAC;AAKF,QAAA,MAAM,0BAA0B,kCAsCtB,CAAC;AAEX,eAAe,0BAA0B,CAAC"}

package/src/schedules/job-tracking-cleanup.js

@@ -0,0 +1,116 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { useDatabase } from '../orm/Database.js';
+import { Schedule } from '../scheduler/Schedule.js';
+const toSqlDateTime = (value) => value.toISOString().slice(0, 19).replace('T', ' ');
+const assertSafeTableName = (raw, label) => {
+    const value = raw.trim();
+    if (value.length === 0)
+        throw ErrorFactory.createGeneralError(`${label} table is empty`);
+    // allow db.schema.table and underscores
+    if (!/^[A-Za-z0-9_.]+$/u.test(value)) {
+        throw ErrorFactory.createGeneralError(`${label} table contains invalid characters: ${value}`);
+    }
+    return value;
+};
+const cleanupJobTrackingBatch = async () => {
+    const connection = Env.get('JOB_TRACKING_DB_CONNECTION', 'default');
+    const jobsTable = assertSafeTableName(Env.get('JOB_TRACKING_DB_TABLE', 'zintrust_jobs'), 'Jobs');
+    const transitionsTable = assertSafeTableName(Env.get('JOB_TRACKING_DB_TRANSITIONS_TABLE', 'zintrust_job_transitions'), 'Transitions');
+    const retentionHoursRaw = Env.get('JOB_TRACKING_CLEANUP_RETENTION_HOURS', '').trim();
+    const retentionHours = retentionHoursRaw.length > 0 ? Number.parseFloat(retentionHoursRaw) : Number.NaN;
+    const retentionDays = Math.max(1, Env.getInt('JOB_TRACKING_CLEANUP_RETENTION_DAYS', 30));
+    const batchSize = Math.max(100, Env.getInt('JOB_TRACKING_CLEANUP_BATCH_SIZE', 5000));
+    const retentionMs = Number.isFinite(retentionHours) && retentionHours > 0
+        ? retentionHours * 60 * 60 * 1000
+        : retentionDays * 24 * 60 * 60 * 1000;
+    const cutoff = new Date(Date.now() - retentionMs);
+    const cutoffSql = toSqlDateTime(cutoff);
+    const db = useDatabase(undefined, connection);
+    const transitionRows = await db
+        .table(transitionsTable)
+        .select('id')
+        .where('transitioned_at', '<=', cutoffSql)
+        .orderBy('id', 'ASC')
+        .limit(batchSize)
+        .get();
+    const transitionIds = (transitionRows ?? [])
+        .map((row) => Number(row.id))
+        .filter((id) => Number.isFinite(id))
+        .map((id) => Math.floor(id));
+    if (transitionIds.length > 0) {
+        await db.table(transitionsTable).whereIn('id', transitionIds).delete();
+    }
+    const jobRows = await db
+        .table(jobsTable)
+        .select('id')
+        .where('status', '=', 'enqueued')
+        .where('updated_at', '<=', cutoffSql)
+        .orderBy('id', 'ASC')
+        .limit(batchSize)
+        .get();
+    const jobIds = (jobRows ?? [])
+        .map((row) => Number(row.id))
+        .filter((id) => Number.isFinite(id))
+        .map((id) => Math.floor(id));
+    if (jobIds.length > 0) {
+        await db.table(jobsTable).whereIn('id', jobIds).delete();
+    }
+    return {
+        retentionDays,
+        cutoffIso: cutoff.toISOString(),
+        batchSize,
+        deletedTransitions: transitionIds.length,
+        deletedJobs: jobIds.length,
+    };
+};
+export const cleanupJobTrackingOnce = async () => {
+    const result = await cleanupJobTrackingBatch();
+    Logger.info('Job tracking cleanup batch completed', {
+        retentionDays: result.retentionDays,
+        cutoff: result.cutoffIso,
+        deletedTransitions: result.deletedTransitions,
+        deletedJobs: result.deletedJobs,
+        batchSize: result.batchSize,
+    });
+};
+const enabled = Env.getBool('JOB_TRACKING_CLEANUP_ENABLED', false);
+const intervalMs = Env.getInt('JOB_TRACKING_CLEANUP_INTERVAL_MS', 6 * 60 * 60 * 1000);
+const JobTrackingCleanupSchedule = Schedule.define('jobTracking.cleanup', async () => {
+    const maxBatches = Math.max(1, Env.getInt('JOB_TRACKING_CLEANUP_MAX_BATCHES', 1));
+    let batchesRun = 0;
+    let deletedTransitionsTotal = 0;
+    let deletedJobsTotal = 0;
+    let retentionDays;
+    let cutoffIso;
+    let batchSize;
+    for (let i = 0; i < maxBatches; i += 1) {
+        // Bounded sequential batches are intentional; we want predictable DB load.
+        // eslint-disable-next-line no-await-in-loop
+        const result = await cleanupJobTrackingBatch();
+        batchesRun += 1;
+        deletedTransitionsTotal += result.deletedTransitions;
+        deletedJobsTotal += result.deletedJobs;
+        retentionDays = result.retentionDays;
+        cutoffIso = result.cutoffIso;
+        batchSize = result.batchSize;
+        if (result.deletedTransitions + result.deletedJobs === 0) {
+            break;
+        }
+    }
+    Logger.info('Job tracking cleanup run completed', {
+        retentionDays,
+        cutoff: cutoffIso,
+        batchSize,
+        batchesRun,
+        maxBatches,
+        deletedTransitionsTotal,
+        deletedJobsTotal,
+    });
+})
+    .intervalMs(intervalMs)
+    .withoutOverlapping({ provider: Env.get('JOB_TRACKING_CLEANUP_LOCK_PROVIDER', 'memory') })
+    .enabledWhen(enabled)
+    .build();
+export default JobTrackingCleanupSchedule;

package/src/schedules/log-cleanup.d.ts

@@ -1,4 +1,3 @@
-import type { ISchedule } from '../scheduler/types';
-declare const LogCleanupSchedule: ISchedule;
+declare const LogCleanupSchedule: import("../scheduler").ISchedule;
 export default LogCleanupSchedule;
 //# sourceMappingURL=log-cleanup.d.ts.map

package/src/schedules/log-cleanup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-cleanup.d.ts","sourceRoot":"","sources":["../../../src/schedules/log-cleanup.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAIlD,QAAA,MAAM,kBAAkB,EAAE,SAYzB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"log-cleanup.d.ts","sourceRoot":"","sources":["../../../src/schedules/log-cleanup.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,kBAAkB,kCASd,CAAC;AAEX,eAAe,kBAAkB,CAAC"}