@webiny/api-event-handler-standalone 0.0.0-unstable.5387e5f7c8 → 0.0.0-unstable.9609e4e0c9

package/scheduler/schedulerServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler/schedulerServer.js","sources":["../../src/scheduler/schedulerServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventDispatcher } from \"@webiny/event-handler-core\";\nimport { ScheduledActionEventType } from \"@webiny/event-handler-core\";\nimport { SCHEDULED_ACTION_EVENT_IDENTIFIER } from \"@webiny/event-handler-core\";\nimport type { IScheduledActionEvent } from \"@webiny/event-handler-core\";\nimport { SchedulerService } from \"@webiny/api-scheduler/shared/abstractions.js\";\nimport { ScheduledActionLambdaHandler } from \"@webiny/api-scheduler\";\nimport { BreeSchedulerService } from \"@webiny/api-scheduler-standalone\";\nimport type { Logger } from \"@webiny/api-core/features/logger/abstractions.js\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\nimport { ScheduledActionRecoverEventType } from \"./ScheduledActionRecoverEventType.js\";\nimport { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER } from \"./ScheduledActionRecoverEventType.js\";\nimport type { IScheduledActionRecoverEvent } from \"./ScheduledActionRecoverEventType.js\";\nimport { RecoverScheduledActionsHandler } from \"./RecoverScheduledActionsHandler.js\";\nimport { ScheduledActionRecoverEventHandler } from \"./ScheduledActionRecoverEventHandler.js\";\n\n/**\n * Minimal console-backed logger for the root scheduler singleton. The real DI Logger is registered\n * per-request (via ApiCoreFeature/LoggerFeature), so it isn't resolvable here at the root where the\n * singleton is built. And even if we bridged to it, timers fire outside any request — there's no\n * request context for a context-aware logger to enrich — so console is functionally equivalent, not\n * a downgrade. Revisit (a shared boot-time logger for all root singletons) tracked in\n * https://github.com/webiny/webiny-js/issues/5446.\n */\nconst consoleLogger: Logger.Interface = {\n    trace: (...args: any[]) => console.trace(...args),\n    debug: (...args: any[]) => console.debug(...args),\n    info: (...args: any[]) => console.info(...args),\n    warn: (...args: any[]) => console.warn(...args),\n    error: (...args: any[]) => console.error(...args),\n    fatal: (...args: any[]) => console.error(...args),\n    log: (...args: any[]) => console.log(...args)\n};\n\n/**\n * ROOT wiring for the standalone (Bree, in-process) scheduler. Unlike AWS (per-request EventBridge\n * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot —\n * the counterpart of the WebSockets connection manager. Registered as `SchedulerService` so\n * per-request create/update/delete (during GraphQL mutations) manipulate that single live timer set.\n *\n * When a timer fires (outside any request), the singleton dispatches a `ScheduledActionEvent`. The\n * handler is the one AWS runs for an EventBridge Scheduler invocation, in a fresh request container.\n */\nexport function registerSchedulerServer(rootContainer: Container): void {\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n\n    const service = new BreeSchedulerService({\n        logger: consoleLogger,\n        onTrigger: async (id, namespace, tenant) => {\n            /*\n             * `scheduleFor` is the time it fired. The event type needs one to recognise the event,\n             * and nothing downstream reads it.\n             */\n            const event: IScheduledActionEvent = {\n                [SCHEDULED_ACTION_EVENT_IDENTIFIER]: {\n                    id,\n                    namespace,\n                    tenant,\n                    scheduleFor: new Date().toISOString()\n                }\n            };\n            try {\n                await dispatcher.dispatch(event);\n            } catch (err) {\n                console.error(`[scheduler] scheduled action \"${id}\" failed:`, err);\n            }\n        }\n    });\n\n    // Register the ONE Bree instance under TWO tokens — two views of the same object:\n    //\n    //   - SchedulerService: the hosting-agnostic contract (create/update/delete/exists) that AWS\n    //     implements too. This is what per-request GraphQL mutations resolve to schedule/reschedule.\n    //   - SchedulerSingleton: typed as the CONCRETE BreeSchedulerService, so it also exposes the\n    //     methods that aren't on that contract — start() and recover(). Those are Bree-only: AWS's\n    //     EventBridge is managed infra (nothing to start) and persists its own schedules (nothing to\n    //     recover), so they don't belong on the shared interface. The boot step + recover handler\n    //     resolve this token precisely because they need start()/recover().\n    //\n    // registerInstance (not register) because it's a single live object holding all tenants' timers —\n    // every caller must get the SAME instance, not a per-scope construction. Registered at root, so\n    // per-request child containers inherit it via the parent chain; nothing registers a per-request\n    // SchedulerService default that would shadow it (unlike e.g. the WS transport's Null default).\n    rootContainer.registerInstance(SchedulerSingleton, service);\n    rootContainer.registerInstance(SchedulerService, service);\n\n    rootContainer.register(ScheduledActionEventType);\n    rootContainer.register(ScheduledActionLambdaHandler);\n\n    rootContainer.register(ScheduledActionRecoverEventType);\n    rootContainer.register(RecoverScheduledActionsHandler);\n}\n\nasync function recoverPendingSchedules(dispatcher: EventDispatcher.Interface): Promise<void> {\n    const event: IScheduledActionRecoverEvent = {\n        [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true\n    };\n\n    try {\n        const result = await dispatcher.dispatch<ScheduledActionRecoverEventHandler.Result>(event);\n        console.log(`[scheduler] boot recovery: re-armed ${result.recovered} pending action(s)`);\n    } catch (err) {\n        console.error(\"[scheduler] boot recovery failed:\", err);\n    }\n}\n\n/**\n * Boot step (onServer): start the timers, then re-arm the persisted schedules. Recovery runs in the\n * background: it executes overdue actions one by one, and the server should not wait for that\n * before it starts listening. A failure is logged and never crashes startup.\n */\nexport async function startSchedulerServer(rootContainer: Container): Promise<void> {\n    await rootContainer.resolve(SchedulerSingleton).start();\n\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n    void recoverPendingSchedules(dispatcher);\n}\n"],"names":["consoleLogger","args","console","registerSchedulerServer","rootContainer","dispatcher","EventDispatcher","service","BreeSchedulerService","id","namespace","tenant","event","SCHEDULED_ACTION_EVENT_IDENTIFIER","Date","err","SchedulerSingleton","SchedulerService","ScheduledActionEventType","ScheduledActionLambdaHandler","ScheduledActionRecoverEventType","RecoverScheduledActionsHandler","recoverPendingSchedules","SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER","result","startSchedulerServer"],"mappings":";;;;;;;AAwBA,MAAMA,gBAAkC;IACpC,OAAO,CAAC,GAAGC,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,KAAK,CAAC,GAAGA,OAAgBC,QAAQ,GAAG,IAAID;AAC5C;AAWO,SAASE,wBAAwBC,aAAwB;IAC5D,MAAMC,aAAaD,cAAc,OAAO,CAACE;IAEzC,MAAMC,UAAU,IAAIC,qBAAqB;QACrC,QAAQR;QACR,WAAW,OAAOS,IAAIC,WAAWC;YAK7B,MAAMC,QAA+B;gBACjC,CAACC,kCAAkC,EAAE;oBACjCJ;oBACAC;oBACAC;oBACA,aAAa,IAAIG,OAAO,WAAW;gBACvC;YACJ;YACA,IAAI;gBACA,MAAMT,WAAW,QAAQ,CAACO;YAC9B,EAAE,OAAOG,KAAK;gBACVb,QAAQ,KAAK,CAAC,CAAC,8BAA8B,EAAEO,GAAG,SAAS,CAAC,EAAEM;YAClE;QACJ;IACJ;IAgBAX,cAAc,gBAAgB,CAACY,oBAAoBT;IACnDH,cAAc,gBAAgB,CAACa,kBAAkBV;IAEjDH,cAAc,QAAQ,CAACc;IACvBd,cAAc,QAAQ,CAACe;IAEvBf,cAAc,QAAQ,CAACgB;IACvBhB,cAAc,QAAQ,CAACiB;AAC3B;AAEA,eAAeC,wBAAwBjB,UAAqC;IACxE,MAAMO,QAAsC;QACxC,CAACW,0CAA0C,EAAE;IACjD;IAEA,IAAI;QACA,MAAMC,SAAS,MAAMnB,WAAW,QAAQ,CAA4CO;QACpFV,QAAQ,GAAG,CAAC,CAAC,oCAAoC,EAAEsB,OAAO,SAAS,CAAC,kBAAkB,CAAC;IAC3F,EAAE,OAAOT,KAAK;QACVb,QAAQ,KAAK,CAAC,qCAAqCa;IACvD;AACJ;AAOO,eAAeU,qBAAqBrB,aAAwB;IAC/D,MAAMA,cAAc,OAAO,CAACY,oBAAoB,KAAK;IAErD,MAAMX,aAAaD,cAAc,OAAO,CAACE;IACpCgB,wBAAwBjB;AACjC"}
+{"version":3,"file":"scheduler/schedulerServer.js","sources":["../../src/scheduler/schedulerServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventDispatcher } from \"@webiny/event-handler-core\";\nimport { ScheduledActionEventType } from \"@webiny/event-handler-core\";\nimport { SCHEDULED_ACTION_EVENT_IDENTIFIER } from \"@webiny/event-handler-core\";\nimport type { IScheduledActionEvent } from \"@webiny/event-handler-core\";\nimport { SchedulerService } from \"@webiny/api-scheduler/shared/abstractions.js\";\nimport { ScheduledActionLambdaHandler } from \"@webiny/api-scheduler\";\nimport { BreeSchedulerService } from \"@webiny/api-scheduler-standalone\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\nimport { ScheduledActionRecoverEventType } from \"./ScheduledActionRecoverEventType.js\";\nimport { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER } from \"./ScheduledActionRecoverEventType.js\";\nimport type { IScheduledActionRecoverEvent } from \"./ScheduledActionRecoverEventType.js\";\nimport { RecoverScheduledActionsHandler } from \"./RecoverScheduledActionsHandler.js\";\nimport { ScheduledActionRecoverEventHandler } from \"./ScheduledActionRecoverEventHandler.js\";\nimport { RunScheduledActionOnceDecorator } from \"./RunScheduledActionOnceDecorator.js\";\nimport { consoleLogger } from \"~/logger/consoleLogger.js\";\n\n/**\n * ROOT wiring for the standalone (Bree, in-process) scheduler. Unlike AWS (per-request EventBridge\n * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot —\n * the counterpart of the WebSockets connection manager. Registered as `SchedulerService` so\n * per-request create/update/delete (during GraphQL mutations) manipulate that single live timer set.\n *\n * When a timer fires (outside any request), the singleton dispatches a `ScheduledActionEvent`. The\n * handler is the one AWS runs for an EventBridge Scheduler invocation, in a fresh request container.\n */\nexport function registerSchedulerServer(rootContainer: Container): void {\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n\n    const service = new BreeSchedulerService({\n        logger: consoleLogger,\n        runAction: async (id, namespace, tenant) => {\n            /*\n             * `scheduleFor` is the time it fired. The event type needs one to recognise the event,\n             * and nothing downstream reads it.\n             */\n            const event: IScheduledActionEvent = {\n                [SCHEDULED_ACTION_EVENT_IDENTIFIER]: {\n                    id,\n                    namespace,\n                    tenant,\n                    scheduleFor: new Date().toISOString()\n                }\n            };\n            try {\n                await dispatcher.dispatch(event);\n            } catch (err) {\n                consoleLogger.error(\n                    { error: err, id, tenant },\n                    \"[scheduler] scheduled action failed\"\n                );\n            }\n        }\n    });\n\n    // Register the ONE Bree instance under TWO tokens — two views of the same object:\n    //\n    //   - SchedulerService: the hosting-agnostic contract (create/update/delete/exists) that AWS\n    //     implements too. This is what per-request GraphQL mutations resolve to schedule/reschedule.\n    //   - SchedulerSingleton: typed as the CONCRETE BreeSchedulerService, so it also exposes the\n    //     methods that aren't on that contract — start() and recover(). Those are Bree-only: AWS's\n    //     EventBridge is managed infra (nothing to start) and persists its own schedules (nothing to\n    //     recover), so they don't belong on the shared interface. The boot step + recover handler\n    //     resolve this token precisely because they need start()/recover().\n    //\n    // registerInstance (not register) because it's a single live object holding all tenants' timers —\n    // every caller must get the SAME instance, not a per-scope construction. Registered at root, so\n    // per-request child containers inherit it via the parent chain; nothing registers a per-request\n    // SchedulerService default that would shadow it (unlike e.g. the WS transport's Null default).\n    rootContainer.registerInstance(SchedulerSingleton, service);\n    rootContainer.registerInstance(SchedulerService, service);\n\n    rootContainer.register(ScheduledActionEventType);\n    rootContainer.register(ScheduledActionLambdaHandler);\n    // Every process holds timers for the same actions; this lets only one of them run each action.\n    rootContainer.registerDecorator(RunScheduledActionOnceDecorator);\n\n    rootContainer.register(ScheduledActionRecoverEventType);\n    rootContainer.register(RecoverScheduledActionsHandler);\n}\n\n// How often each process re-arms pending actions and fires overdue ones.\nconst RECOVER_EVERY_MS = 60_000;\n\nasync function recoverPendingSchedules(\n    dispatcher: EventDispatcher.Interface,\n    atBoot: boolean\n): Promise<void> {\n    const event: IScheduledActionRecoverEvent = {\n        [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true\n    };\n\n    try {\n        const result = await dispatcher.dispatch<ScheduledActionRecoverEventHandler.Result>(event);\n        if (atBoot) {\n            consoleLogger.info(\n                { recovered: result.recovered },\n                \"[scheduler] boot recovery re-armed pending actions\"\n            );\n        }\n        if (result.failedTenants.length > 0) {\n            consoleLogger.error(\n                { tenants: result.failedTenants },\n                \"[scheduler] recovery failed for some tenants\"\n            );\n        }\n    } catch (err) {\n        consoleLogger.error({ error: err }, \"[scheduler] recovery failed\");\n    }\n}\n\n/**\n * Boot step (onServer): start the timers, then re-arm the persisted schedules, at boot and then every\n * minute. Recovery runs in the background: it executes overdue actions one by one, and the server\n * should not wait for that before it starts listening. A failure is logged and never crashes startup.\n *\n * Running it every minute is what makes several processes work. Each holds its own timers, so an\n * action scheduled or moved through one process reaches the others' timers within a minute, and an\n * action whose process died is still fired, as an overdue one. `RunScheduledActionOnceDecorator`\n * keeps the processes from all running it. Runs never overlap.\n *\n * Returns a function for the shutdown: it stops the timers and recovery, then waits up to\n * `timeoutMs` for actions already running.\n */\nexport async function startSchedulerServer(\n    rootContainer: Container\n): Promise<(timeoutMs: number) => Promise<void>> {\n    const scheduler = rootContainer.resolve(SchedulerSingleton);\n    await scheduler.start();\n\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n    let recovering = false;\n    const recover = async (atBoot: boolean) => {\n        if (recovering) {\n            return;\n        }\n        recovering = true;\n        try {\n            await recoverPendingSchedules(dispatcher, atBoot);\n        } finally {\n            recovering = false;\n        }\n    };\n\n    void recover(true);\n    const everyMinute = setInterval(() => {\n        void recover(false);\n    }, RECOVER_EVERY_MS);\n\n    return async (timeoutMs: number) => {\n        clearInterval(everyMinute);\n        await scheduler.stop();\n        await scheduler.waitForRunning(timeoutMs);\n    };\n}\n"],"names":["registerSchedulerServer","rootContainer","dispatcher","EventDispatcher","service","BreeSchedulerService","consoleLogger","id","namespace","tenant","event","SCHEDULED_ACTION_EVENT_IDENTIFIER","Date","err","SchedulerSingleton","SchedulerService","ScheduledActionEventType","ScheduledActionLambdaHandler","RunScheduledActionOnceDecorator","ScheduledActionRecoverEventType","RecoverScheduledActionsHandler","RECOVER_EVERY_MS","recoverPendingSchedules","atBoot","SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER","result","startSchedulerServer","scheduler","recovering","recover","everyMinute","setInterval","timeoutMs","clearInterval"],"mappings":";;;;;;;;;AA0BO,SAASA,wBAAwBC,aAAwB;IAC5D,MAAMC,aAAaD,cAAc,OAAO,CAACE;IAEzC,MAAMC,UAAU,IAAIC,qBAAqB;QACrC,QAAQC;QACR,WAAW,OAAOC,IAAIC,WAAWC;YAK7B,MAAMC,QAA+B;gBACjC,CAACC,kCAAkC,EAAE;oBACjCJ;oBACAC;oBACAC;oBACA,aAAa,IAAIG,OAAO,WAAW;gBACvC;YACJ;YACA,IAAI;gBACA,MAAMV,WAAW,QAAQ,CAACQ;YAC9B,EAAE,OAAOG,KAAK;gBACVP,cAAc,KAAK,CACf;oBAAE,OAAOO;oBAAKN;oBAAIE;gBAAO,GACzB;YAER;QACJ;IACJ;IAgBAR,cAAc,gBAAgB,CAACa,oBAAoBV;IACnDH,cAAc,gBAAgB,CAACc,kBAAkBX;IAEjDH,cAAc,QAAQ,CAACe;IACvBf,cAAc,QAAQ,CAACgB;IAEvBhB,cAAc,iBAAiB,CAACiB;IAEhCjB,cAAc,QAAQ,CAACkB;IACvBlB,cAAc,QAAQ,CAACmB;AAC3B;AAGA,MAAMC,mBAAmB;AAEzB,eAAeC,wBACXpB,UAAqC,EACrCqB,MAAe;IAEf,MAAMb,QAAsC;QACxC,CAACc,0CAA0C,EAAE;IACjD;IAEA,IAAI;QACA,MAAMC,SAAS,MAAMvB,WAAW,QAAQ,CAA4CQ;QACpF,IAAIa,QACAjB,cAAc,IAAI,CACd;YAAE,WAAWmB,OAAO,SAAS;QAAC,GAC9B;QAGR,IAAIA,OAAO,aAAa,CAAC,MAAM,GAAG,GAC9BnB,cAAc,KAAK,CACf;YAAE,SAASmB,OAAO,aAAa;QAAC,GAChC;IAGZ,EAAE,OAAOZ,KAAK;QACVP,cAAc,KAAK,CAAC;YAAE,OAAOO;QAAI,GAAG;IACxC;AACJ;AAeO,eAAea,qBAClBzB,aAAwB;IAExB,MAAM0B,YAAY1B,cAAc,OAAO,CAACa;IACxC,MAAMa,UAAU,KAAK;IAErB,MAAMzB,aAAaD,cAAc,OAAO,CAACE;IACzC,IAAIyB,aAAa;IACjB,MAAMC,UAAU,OAAON;QACnB,IAAIK,YACA;QAEJA,aAAa;QACb,IAAI;YACA,MAAMN,wBAAwBpB,YAAYqB;QAC9C,SAAU;YACNK,aAAa;QACjB;IACJ;IAEKC,QAAQ;IACb,MAAMC,cAAcC,YAAY;QACvBF,QAAQ;IACjB,GAAGR;IAEH,OAAO,OAAOW;QACVC,cAAcH;QACd,MAAMH,UAAU,IAAI;QACpB,MAAMA,UAAU,cAAc,CAACK;IACnC;AACJ"}