@webiny/background-tasks-standalone 0.0.0-unstable.5387e5f7c8

package/BackgroundTasksStandaloneFeature.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Background tasks for the standalone server. Register at the root container: the loop is one
+ * long-lived object for the whole process, and it needs the root's `EventDispatcher`.
+ */
+export declare const BackgroundTasksStandaloneFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/BackgroundTasksStandaloneFeature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { BackgroundTaskEventType } from "@webiny/event-handler-core";
+import { DispatchingTaskLoop } from "./loop/DispatchingTaskLoop.js";
+import { InProcessTaskService } from "./service/InProcessTaskService.js";
+import { InProcessBackgroundTaskHandler } from "./handlers/InProcessBackgroundTaskHandler.js";
+const BackgroundTasksStandaloneFeature = createFeature({
+    name: "BackgroundTasksServer",
+    register (container) {
+        container.register(BackgroundTaskEventType);
+        container.register(InProcessBackgroundTaskHandler);
+        container.register(DispatchingTaskLoop).inSingletonScope();
+        container.register(InProcessTaskService);
+    }
+});
+export { BackgroundTasksStandaloneFeature };
+
+//# sourceMappingURL=BackgroundTasksStandaloneFeature.js.map

package/BackgroundTasksStandaloneFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTasksStandaloneFeature.js","sources":["../src/BackgroundTasksStandaloneFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { BackgroundTaskEventType } from \"@webiny/event-handler-core\";\nimport { DispatchingTaskLoop } from \"~/loop/DispatchingTaskLoop.js\";\nimport { InProcessTaskService } from \"~/service/InProcessTaskService.js\";\nimport { InProcessBackgroundTaskHandler } from \"~/handlers/InProcessBackgroundTaskHandler.js\";\n\n/**\n * Background tasks for the standalone server. Register at the root container: the loop is one\n * long-lived object for the whole process, and it needs the root's `EventDispatcher`.\n */\nexport const BackgroundTasksStandaloneFeature = createFeature({\n    name: \"BackgroundTasksServer\",\n    register(container) {\n        container.register(BackgroundTaskEventType);\n        container.register(InProcessBackgroundTaskHandler);\n        container.register(DispatchingTaskLoop).inSingletonScope();\n        container.register(InProcessTaskService);\n    }\n});\n"],"names":["BackgroundTasksStandaloneFeature","createFeature","container","BackgroundTaskEventType","InProcessBackgroundTaskHandler","DispatchingTaskLoop","InProcessTaskService"],"mappings":";;;;;AAUO,MAAMA,mCAAmCC,cAAc;IAC1D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG,qBAAqB,gBAAgB;QACxDH,UAAU,QAAQ,CAACI;IACvB;AACJ"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/background-tasks-standalone
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/domain/TaskLoop.d.ts

@@ -0,0 +1,15 @@
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
+/**
+ * Drives a triggered task to completion inside this process: runs one iteration, waits as long as
+ * the iteration asks, and runs the next until the task stops asking to continue. The standalone
+ * counterpart of the Step Functions state machine that drives a task on AWS.
+ *
+ * `start` returns at once. The task runs after the request that triggered it has finished.
+ */
+export interface ITaskLoop {
+    start(event: IBackgroundTaskEvent): void;
+}
+export declare const TaskLoop: import("@webiny/di").Abstraction<ITaskLoop>;
+export declare namespace TaskLoop {
+    type Interface = ITaskLoop;
+}

package/domain/TaskLoop.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const TaskLoop = createAbstraction("BackgroundTasks/TaskLoop");
+export { TaskLoop };
+
+//# sourceMappingURL=TaskLoop.js.map

package/domain/TaskLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/TaskLoop.js","sources":["../../src/domain/TaskLoop.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\n\n/**\n * Drives a triggered task to completion inside this process: runs one iteration, waits as long as\n * the iteration asks, and runs the next until the task stops asking to continue. The standalone\n * counterpart of the Step Functions state machine that drives a task on AWS.\n *\n * `start` returns at once. The task runs after the request that triggered it has finished.\n */\nexport interface ITaskLoop {\n    start(event: IBackgroundTaskEvent): void;\n}\n\nexport const TaskLoop = createAbstraction<ITaskLoop>(\"BackgroundTasks/TaskLoop\");\n\nexport namespace TaskLoop {\n    export type Interface = ITaskLoop;\n}\n"],"names":["TaskLoop","createAbstraction"],"mappings":";AAcO,MAAMA,WAAWC,kBAA6B"}

package/handlers/InProcessBackgroundTaskHandler.d.ts

@@ -0,0 +1,22 @@
+import type { Container } from "@webiny/feature/api";
+import { BackgroundTaskEventHandler } from "@webiny/event-handler-core";
+import type { EventContext } from "@webiny/event-handler-core";
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
+import { RawTenantId } from "@webiny/api-core/features/requestContext/index.js";
+import { RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+/**
+ * Runs one iteration of a background task in the request container the dispatcher built for it.
+ * The standalone counterpart of `BackgroundTaskLambdaHandler`: same tenant set-up and runner, with
+ * a process timer in place of the Lambda countdown.
+ */
+declare class InProcessBackgroundTaskHandlerImpl implements BackgroundTaskEventHandler.Interface {
+    private readonly container;
+    private readonly rawTenantId;
+    private readonly tenantLoader;
+    constructor(container: Container, rawTenantId: RawTenantId.Interface, tenantLoader: RequestTenantLoader.Interface);
+    execute(eventCtx: EventContext<IBackgroundTaskEvent>): Promise<unknown>;
+}
+export declare const InProcessBackgroundTaskHandler: typeof InProcessBackgroundTaskHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core/features/backgroundTask/BackgroundTaskEventHandler").IBackgroundTaskEventHandler>;
+};
+export {};

package/handlers/InProcessBackgroundTaskHandler.js

@@ -0,0 +1,34 @@
+import { BackgroundTaskEventHandler, RequestContainer } from "@webiny/event-handler-core";
+import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+import { TaskRunner } from "@webiny/background-tasks/api/runner/index.js";
+import { TaskEventValidation } from "@webiny/background-tasks/api/runner/TaskEventValidation.js";
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+class InProcessBackgroundTaskHandlerImpl {
+    constructor(container, rawTenantId, tenantLoader){
+        this.container = container;
+        this.rawTenantId = rawTenantId;
+        this.tenantLoader = tenantLoader;
+    }
+    async execute(eventCtx) {
+        const taskEvent = eventCtx.event;
+        this.rawTenantId.set(taskEvent.tenant);
+        await this.tenantLoader.establish();
+        const ctx = {
+            container: this.container
+        };
+        const timer = new ProcessTimer();
+        const runner = new TaskRunner(ctx, timer, new TaskEventValidation());
+        return runner.run(taskEvent);
+    }
+}
+const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({
+    implementation: InProcessBackgroundTaskHandlerImpl,
+    dependencies: [
+        RequestContainer,
+        RawTenantId,
+        RequestTenantLoader
+    ]
+});
+export { InProcessBackgroundTaskHandler };
+
+//# sourceMappingURL=InProcessBackgroundTaskHandler.js.map

package/handlers/InProcessBackgroundTaskHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/InProcessBackgroundTaskHandler.js","sources":["../../src/handlers/InProcessBackgroundTaskHandler.ts"],"sourcesContent":["import type { Container } from \"@webiny/feature/api\";\nimport { BackgroundTaskEventHandler } from \"@webiny/event-handler-core\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport type { EventContext } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { RawTenantId } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { RequestTenantLoader } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { TaskRunner } from \"@webiny/background-tasks/api/runner/index.js\";\nimport { TaskEventValidation } from \"@webiny/background-tasks/api/runner/TaskEventValidation.js\";\nimport type { Context } from \"@webiny/background-tasks/api/types.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\n\n/**\n * Runs one iteration of a background task in the request container the dispatcher built for it.\n * The standalone counterpart of `BackgroundTaskLambdaHandler`: same tenant set-up and runner, with\n * a process timer in place of the Lambda countdown.\n */\nclass InProcessBackgroundTaskHandlerImpl implements BackgroundTaskEventHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly rawTenantId: RawTenantId.Interface,\n        private readonly tenantLoader: RequestTenantLoader.Interface\n    ) {}\n\n    public async execute(eventCtx: EventContext<IBackgroundTaskEvent>): Promise<unknown> {\n        const taskEvent = eventCtx.event;\n\n        this.rawTenantId.set(taskEvent.tenant);\n        await this.tenantLoader.establish();\n\n        // TaskRunner still takes the legacy context object, which now only carries the container.\n        const ctx: Record<string, any> = { container: this.container };\n\n        const timer = new ProcessTimer();\n        const runner = new TaskRunner(ctx as Context, timer, new TaskEventValidation());\n\n        // The loop reads `status`, `wait` and `delay` from this to decide what happens next.\n        return runner.run(taskEvent);\n    }\n}\n\nexport const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({\n    implementation: InProcessBackgroundTaskHandlerImpl,\n    dependencies: [RequestContainer, RawTenantId, RequestTenantLoader]\n});\n"],"names":["InProcessBackgroundTaskHandlerImpl","container","rawTenantId","tenantLoader","eventCtx","taskEvent","ctx","timer","ProcessTimer","runner","TaskRunner","TaskEventValidation","InProcessBackgroundTaskHandler","BackgroundTaskEventHandler","RequestContainer","RawTenantId","RequestTenantLoader"],"mappings":";;;;;AAiBA,MAAMA;IACF,YACqBC,SAAoB,EACpBC,WAAkC,EAClCC,YAA2C,CAC9D;aAHmBF,SAAS,GAATA;aACAC,WAAW,GAAXA;aACAC,YAAY,GAAZA;IAClB;IAEH,MAAa,QAAQC,QAA4C,EAAoB;QACjF,MAAMC,YAAYD,SAAS,KAAK;QAEhC,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,UAAU,MAAM;QACrC,MAAM,IAAI,CAAC,YAAY,CAAC,SAAS;QAGjC,MAAMC,MAA2B;YAAE,WAAW,IAAI,CAAC,SAAS;QAAC;QAE7D,MAAMC,QAAQ,IAAIC;QAClB,MAAMC,SAAS,IAAIC,WAAWJ,KAAgBC,OAAO,IAAII;QAGzD,OAAOF,OAAO,GAAG,CAACJ;IACtB;AACJ;AAEO,MAAMO,iCAAiCC,2BAA2B,oBAAoB,CAAC;IAC1F,gBAAgBb;IAChB,cAAc;QAACc;QAAkBC;QAAaC;KAAoB;AACtE"}

package/index.d.ts

@@ -0,0 +1 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";

package/index.js

@@ -0,0 +1 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";

package/loop/DispatchingTaskLoop.d.ts

@@ -0,0 +1,17 @@
+import { EventDispatcher } from "@webiny/event-handler-core";
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
+import { TaskLoop } from "../domain/TaskLoop.js";
+/**
+ * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like
+ * an HTTP request would be. Root singleton: one loop drives every task in the process.
+ */
+declare class DispatchingTaskLoopImpl implements TaskLoop.Interface {
+    private readonly dispatcher;
+    constructor(dispatcher: EventDispatcher.Interface);
+    start(event: IBackgroundTaskEvent): void;
+    private run;
+}
+export declare const DispatchingTaskLoop: typeof DispatchingTaskLoopImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/TaskLoop.js").ITaskLoop>;
+};
+export {};

package/loop/DispatchingTaskLoop.js

@@ -0,0 +1,48 @@
+import { EventDispatcher } from "@webiny/event-handler-core";
+import { TaskLoop } from "../domain/TaskLoop.js";
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+const MAX_TASK_DURATION_MS = 86400000;
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+class DispatchingTaskLoopImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    start(event) {
+        this.run(event);
+    }
+    async run(firstEvent) {
+        const taskId = firstEvent.webinyTaskId;
+        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);
+        let event = firstEvent;
+        while(timer.getRemainingMilliseconds() > 0){
+            let result;
+            try {
+                result = await this.dispatcher.dispatch(event);
+            } catch (error) {
+                console.error(`Background task "${taskId}" failed:`, error);
+                return;
+            }
+            const status = result?.status;
+            if ("done" === status || "aborted" === status) return;
+            if ("continue" !== status) return void console.error(`Background task "${taskId}" stopped with status "${status}":`, result);
+            event = {
+                ...event,
+                delay: result?.delay ?? -1
+            };
+            const wait = result?.wait ?? 0;
+            if (wait > 0) await sleep(1000 * wait);
+        }
+        console.error(`Background task "${taskId}" exceeded the maximum duration.`);
+    }
+}
+const DispatchingTaskLoop = TaskLoop.createImplementation({
+    implementation: DispatchingTaskLoopImpl,
+    dependencies: [
+        EventDispatcher
+    ]
+});
+export { DispatchingTaskLoop };
+
+//# sourceMappingURL=DispatchingTaskLoop.js.map

package/loop/DispatchingTaskLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop/DispatchingTaskLoop.js","sources":["../../src/loop/DispatchingTaskLoop.ts"],"sourcesContent":["import { EventDispatcher } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { TaskLoop } from \"~/domain/TaskLoop.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\n\n// 24 hours, the most one task may run in total.\nconst MAX_TASK_DURATION_MS = 86_400_000;\n\n// What the runner answers for one iteration; only the fields the loop reads.\ninterface IIterationResult {\n    status?: string;\n    wait?: number;\n    delay?: number;\n}\n\nfunction sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like\n * an HTTP request would be. Root singleton: one loop drives every task in the process.\n */\nclass DispatchingTaskLoopImpl implements TaskLoop.Interface {\n    public constructor(private readonly dispatcher: EventDispatcher.Interface) {}\n\n    public start(event: IBackgroundTaskEvent): void {\n        void this.run(event);\n    }\n\n    private async run(firstEvent: IBackgroundTaskEvent): Promise<void> {\n        const taskId = firstEvent.webinyTaskId;\n        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);\n        let event = firstEvent;\n\n        while (timer.getRemainingMilliseconds() > 0) {\n            let result: IIterationResult | undefined;\n            try {\n                result = await this.dispatcher.dispatch<IIterationResult>(event);\n            } catch (error) {\n                console.error(`Background task \"${taskId}\" failed:`, error);\n                return;\n            }\n\n            const status = result?.status;\n            if (status === \"done\" || status === \"aborted\") {\n                return;\n            }\n            if (status !== \"continue\") {\n                console.error(\n                    `Background task \"${taskId}\" stopped with status \"${status}\":`,\n                    result\n                );\n                return;\n            }\n\n            /*\n             * The first event carries the trigger's delay, and the runner answers it with `continue`\n             * and `wait: delay` without running anything. Every later event must carry the delay the\n             * runner sent back (-1), as the Step Functions state does on AWS. Resending the original\n             * delay would make the runner answer `continue` forever.\n             */\n            event = { ...event, delay: result?.delay ?? -1 };\n\n            const wait = result?.wait ?? 0;\n            if (wait > 0) {\n                await sleep(wait * 1000);\n            }\n        }\n\n        console.error(`Background task \"${taskId}\" exceeded the maximum duration.`);\n    }\n}\n\nexport const DispatchingTaskLoop = TaskLoop.createImplementation({\n    implementation: DispatchingTaskLoopImpl,\n    dependencies: [EventDispatcher]\n});\n"],"names":["MAX_TASK_DURATION_MS","sleep","ms","Promise","resolve","setTimeout","DispatchingTaskLoopImpl","dispatcher","event","firstEvent","taskId","timer","ProcessTimer","result","error","console","status","wait","DispatchingTaskLoop","TaskLoop","EventDispatcher"],"mappings":";;;AAMA,MAAMA,uBAAuB;AAS7B,SAASC,MAAMC,EAAU;IACrB,OAAO,IAAIC,QAAQC,CAAAA,UAAWC,WAAWD,SAASF;AACtD;AAMA,MAAMI;IACF,YAAoCC,UAAqC,CAAE;aAAvCA,UAAU,GAAVA;IAAwC;IAErE,MAAMC,KAA2B,EAAQ;QACvC,IAAI,CAAC,GAAG,CAACA;IAClB;IAEA,MAAc,IAAIC,UAAgC,EAAiB;QAC/D,MAAMC,SAASD,WAAW,YAAY;QACtC,MAAME,QAAQ,IAAIC,aAAaZ;QAC/B,IAAIQ,QAAQC;QAEZ,MAAOE,MAAM,wBAAwB,KAAK,EAAG;YACzC,IAAIE;YACJ,IAAI;gBACAA,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAmBL;YAC9D,EAAE,OAAOM,OAAO;gBACZC,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAEL,OAAO,SAAS,CAAC,EAAEI;gBACrD;YACJ;YAEA,MAAME,SAASH,QAAQ;YACvB,IAAIG,AAAW,WAAXA,UAAqBA,AAAW,cAAXA,QACrB;YAEJ,IAAIA,AAAW,eAAXA,QAAuB,YACvBD,QAAQ,KAAK,CACT,CAAC,iBAAiB,EAAEL,OAAO,uBAAuB,EAAEM,OAAO,EAAE,CAAC,EAC9DH;YAWRL,QAAQ;gBAAE,GAAGA,KAAK;gBAAE,OAAOK,QAAQ,SAAS;YAAG;YAE/C,MAAMI,OAAOJ,QAAQ,QAAQ;YAC7B,IAAII,OAAO,GACP,MAAMhB,MAAMgB,AAAO,OAAPA;QAEpB;QAEAF,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAEL,OAAO,gCAAgC,CAAC;IAC9E;AACJ;AAEO,MAAMQ,sBAAsBC,SAAS,oBAAoB,CAAC;IAC7D,gBAAgBb;IAChB,cAAc;QAACc;KAAgB;AACnC"}

package/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "@webiny/background-tasks-standalone",
+	"version": "0.0.0-unstable.5387e5f7c8",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "Node server transport for Webiny background tasks (worker-thread orchestrator).",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/background-tasks-standalone"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/background-tasks": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/event-handler-core": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/feature": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/utils": "0.0.0-unstable.5387e5f7c8"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/di": "2.0.0",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/service/InProcessTaskService.d.ts

@@ -0,0 +1,19 @@
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { TaskLoop } from "../domain/TaskLoop.js";
+/**
+ * Starts a triggered task in this process. Builds the same event Step Functions would deliver on
+ * AWS and hands it to the task loop. `endpoint`, `executionName` and `stateMachineId` only satisfy
+ * the runner's event validation; nothing reads them off AWS.
+ */
+declare class InProcessTaskServiceImpl implements TaskService.Interface {
+    private readonly tenantContext;
+    private readonly taskLoop;
+    constructor(tenantContext: TenantContext.Interface, taskLoop: TaskLoop.Interface);
+    send(task: TaskService.SendTaskParams, delay: number): Promise<unknown>;
+    fetch(): Promise<null>;
+}
+export declare const InProcessTaskService: typeof InProcessTaskServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/background-tasks/api/domain/TaskService.js").ITaskService>;
+};
+export {};

package/service/InProcessTaskService.js

@@ -0,0 +1,39 @@
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { TaskLoop } from "../domain/TaskLoop.js";
+class InProcessTaskServiceImpl {
+    constructor(tenantContext, taskLoop){
+        this.tenantContext = tenantContext;
+        this.taskLoop = taskLoop;
+    }
+    async send(task, delay) {
+        const tenant = this.tenantContext.getTenant();
+        if (!tenant) return null;
+        const event = {
+            webinyTaskId: task.id,
+            webinyTaskDefinitionId: task.definitionId,
+            tenant: tenant.id,
+            delay,
+            endpoint: "in-process",
+            executionName: task.id,
+            stateMachineId: ""
+        };
+        this.taskLoop.start(event);
+        return {
+            taskId: task.id
+        };
+    }
+    async fetch() {
+        return null;
+    }
+}
+const InProcessTaskService = TaskService.createImplementation({
+    implementation: InProcessTaskServiceImpl,
+    dependencies: [
+        TenantContext,
+        TaskLoop
+    ]
+});
+export { InProcessTaskService };
+
+//# sourceMappingURL=InProcessTaskService.js.map

package/service/InProcessTaskService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service/InProcessTaskService.js","sources":["../../src/service/InProcessTaskService.ts"],"sourcesContent":["import type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { TaskService } from \"@webiny/background-tasks/api/domain/TaskService.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { TaskLoop } from \"~/domain/TaskLoop.js\";\n\n/**\n * Starts a triggered task in this process. Builds the same event Step Functions would deliver on\n * AWS and hands it to the task loop. `endpoint`, `executionName` and `stateMachineId` only satisfy\n * the runner's event validation; nothing reads them off AWS.\n */\nclass InProcessTaskServiceImpl implements TaskService.Interface {\n    public constructor(\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly taskLoop: TaskLoop.Interface\n    ) {}\n\n    public async send(task: TaskService.SendTaskParams, delay: number): Promise<unknown> {\n        const tenant = this.tenantContext.getTenant();\n        if (!tenant) {\n            return null;\n        }\n\n        const event: IBackgroundTaskEvent = {\n            webinyTaskId: task.id,\n            webinyTaskDefinitionId: task.definitionId,\n            tenant: tenant.id,\n            delay,\n            endpoint: \"in-process\",\n            executionName: task.id,\n            stateMachineId: \"\"\n        };\n\n        this.taskLoop.start(event);\n\n        return { taskId: task.id };\n    }\n\n    public async fetch(): Promise<null> {\n        // A running task has no execution record outside the task itself.\n        return null;\n    }\n}\n\nexport const InProcessTaskService = TaskService.createImplementation({\n    implementation: InProcessTaskServiceImpl,\n    dependencies: [TenantContext, TaskLoop]\n});\n"],"names":["InProcessTaskServiceImpl","tenantContext","taskLoop","task","delay","tenant","event","InProcessTaskService","TaskService","TenantContext","TaskLoop"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,aAAsC,EACtCC,QAA4B,CAC/C;aAFmBD,aAAa,GAAbA;aACAC,QAAQ,GAARA;IAClB;IAEH,MAAa,KAAKC,IAAgC,EAAEC,KAAa,EAAoB;QACjF,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,IAAI,CAACA,QACD,OAAO;QAGX,MAAMC,QAA8B;YAChC,cAAcH,KAAK,EAAE;YACrB,wBAAwBA,KAAK,YAAY;YACzC,QAAQE,OAAO,EAAE;YACjBD;YACA,UAAU;YACV,eAAeD,KAAK,EAAE;YACtB,gBAAgB;QACpB;QAEA,IAAI,CAAC,QAAQ,CAAC,KAAK,CAACG;QAEpB,OAAO;YAAE,QAAQH,KAAK,EAAE;QAAC;IAC7B;IAEA,MAAa,QAAuB;QAEhC,OAAO;IACX;AACJ;AAEO,MAAMI,uBAAuBC,YAAY,oBAAoB,CAAC;IACjE,gBAAgBR;IAChB,cAAc;QAACS;QAAeC;KAAS;AAC3C"}

package/timer/ProcessTimer.d.ts

@@ -0,0 +1,8 @@
+import type { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+export declare class ProcessTimer implements Timer.Interface {
+    private readonly startTime;
+    private readonly maxDurationMs;
+    constructor(maxDurationMs?: number);
+    getRemainingMilliseconds(): number;
+    getRemainingSeconds(): number;
+}

package/timer/ProcessTimer.js

@@ -0,0 +1,19 @@
+const DEFAULT_MAX_DURATION_MS = 86400000;
+class ProcessTimer {
+    constructor(maxDurationMs = DEFAULT_MAX_DURATION_MS){
+        this.startTime = process.hrtime();
+        this.maxDurationMs = maxDurationMs;
+    }
+    getRemainingMilliseconds() {
+        const elapsed = process.hrtime(this.startTime);
+        const elapsedMs = 1000 * elapsed[0] + elapsed[1] / 1000000;
+        const remaining = this.maxDurationMs - elapsedMs;
+        return remaining > 0 ? remaining : 0;
+    }
+    getRemainingSeconds() {
+        return Math.floor(this.getRemainingMilliseconds() / 1000);
+    }
+}
+export { ProcessTimer };
+
+//# sourceMappingURL=ProcessTimer.js.map

package/timer/ProcessTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer/ProcessTimer.js","sources":["../../src/timer/ProcessTimer.ts"],"sourcesContent":["import type { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\n\nconst DEFAULT_MAX_DURATION_MS = 86_400_000; /* 24 hours. */\n\nexport class ProcessTimer implements Timer.Interface {\n    private readonly startTime: [number, number];\n    private readonly maxDurationMs: number;\n\n    public constructor(maxDurationMs: number = DEFAULT_MAX_DURATION_MS) {\n        this.startTime = process.hrtime();\n        this.maxDurationMs = maxDurationMs;\n    }\n\n    public getRemainingMilliseconds(): number {\n        const elapsed = process.hrtime(this.startTime);\n        const elapsedMs = elapsed[0] * 1000 + elapsed[1] / 1_000_000;\n        const remaining = this.maxDurationMs - elapsedMs;\n        return remaining > 0 ? remaining : 0;\n    }\n\n    public getRemainingSeconds(): number {\n        return Math.floor(this.getRemainingMilliseconds() / 1000);\n    }\n}\n"],"names":["DEFAULT_MAX_DURATION_MS","ProcessTimer","maxDurationMs","process","elapsed","elapsedMs","remaining","Math"],"mappings":"AAEA,MAAMA,0BAA0B;AAEzB,MAAMC;IAIT,YAAmBC,gBAAwBF,uBAAuB,CAAE;QAChE,IAAI,CAAC,SAAS,GAAGG,QAAQ,MAAM;QAC/B,IAAI,CAAC,aAAa,GAAGD;IACzB;IAEO,2BAAmC;QACtC,MAAME,UAAUD,QAAQ,MAAM,CAAC,IAAI,CAAC,SAAS;QAC7C,MAAME,YAAYD,AAAa,OAAbA,OAAO,CAAC,EAAE,GAAUA,OAAO,CAAC,EAAE,GAAG;QACnD,MAAME,YAAY,IAAI,CAAC,aAAa,GAAGD;QACvC,OAAOC,YAAY,IAAIA,YAAY;IACvC;IAEO,sBAA8B;QACjC,OAAOC,KAAK,KAAK,CAAC,IAAI,CAAC,wBAAwB,KAAK;IACxD;AACJ"}