@webiny/background-tasks-aws 0.0.0-unstable.0d717d18dd

package/BackgroundTaskLambdaHandler.d.ts

@@ -0,0 +1,13 @@
+import type { Container } from "@webiny/feature/api";
+import { BackgroundTaskEventHandler } from "@webiny/event-handler-aws/abstractions/handlers/BackgroundTaskEventHandler.js";
+import type { EventContext, NextFunction } from "@webiny/event-handler-core";
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-aws/eventTypes/BackgroundTaskEventType.js";
+declare class BackgroundTaskLambdaHandlerImpl implements BackgroundTaskEventHandler.Interface {
+    private container;
+    constructor(container: Container);
+    execute(eventCtx: EventContext<IBackgroundTaskEvent>, _next: NextFunction): Promise<unknown>;
+}
+export declare const BackgroundTaskLambdaHandler: typeof BackgroundTaskLambdaHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-aws/abstractions/handlers/BackgroundTaskEventHandler.js").IBackgroundTaskEventHandler>;
+};
+export {};

package/BackgroundTaskLambdaHandler.js

@@ -0,0 +1,48 @@
+import { AwsLambdaContext } from "@webiny/event-handler-aws/abstractions/AwsLambdaContext.js";
+import { BackgroundTaskEventHandler } from "@webiny/event-handler-aws/abstractions/handlers/BackgroundTaskEventHandler.js";
+import { GraphQLContextEnhancer, GraphQLContextualSchema } from "@webiny/api-graphql";
+import { RequestContainer, runRequestContextInitializers } 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 { LambdaTimer } from "./timer/LambdaTimer.js";
+const FALLBACK_MAX_RUNNING_MILLISECONDS = 840000;
+class BackgroundTaskLambdaHandlerImpl {
+    constructor(container){
+        this.container = container;
+    }
+    async execute(eventCtx, _next) {
+        const fallbackStartTime = Date.now();
+        const taskEvent = eventCtx.event?.payload || eventCtx.event;
+        if (taskEvent?.tenant) {
+            this.container.resolve(RawTenantId).set(taskEvent.tenant);
+            await this.container.resolve(RequestTenantLoader).establish();
+        }
+        await runRequestContextInitializers(this.container, {
+            continueOnError: true
+        });
+        const ctx = {
+            container: this.container
+        };
+        for (const enhancer of this.container.resolveAll(GraphQLContextEnhancer))await enhancer.enhance(ctx);
+        for (const schema of this.container.resolveAll(GraphQLContextualSchema))await schema.build(ctx);
+        const lambdaContext = this.container.resolve(AwsLambdaContext);
+        const timer = new LambdaTimer({
+            getRemainingTimeInMillis: ()=>{
+                if (lambdaContext.isSet()) return lambdaContext.get().getRemainingTimeInMillis();
+                return fallbackStartTime + FALLBACK_MAX_RUNNING_MILLISECONDS - Date.now();
+            }
+        });
+        const runner = new TaskRunner(ctx, timer, new TaskEventValidation());
+        return runner.run(taskEvent);
+    }
+}
+const BackgroundTaskLambdaHandler = BackgroundTaskEventHandler.createImplementation({
+    implementation: BackgroundTaskLambdaHandlerImpl,
+    dependencies: [
+        RequestContainer
+    ]
+});
+export { BackgroundTaskLambdaHandler };
+
+//# sourceMappingURL=BackgroundTaskLambdaHandler.js.map

package/BackgroundTaskLambdaHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTaskLambdaHandler.js","sources":["../src/BackgroundTaskLambdaHandler.ts"],"sourcesContent":["import type { Container } from \"@webiny/feature/api\";\nimport { AwsLambdaContext } from \"@webiny/event-handler-aws/abstractions/AwsLambdaContext.js\";\nimport { BackgroundTaskEventHandler } from \"@webiny/event-handler-aws/abstractions/handlers/BackgroundTaskEventHandler.js\";\nimport { GraphQLContextEnhancer, GraphQLContextualSchema } from \"@webiny/api-graphql\";\nimport { RequestContainer, runRequestContextInitializers } from \"@webiny/event-handler-core\";\nimport {\n    RawTenantId,\n    RequestTenantLoader\n} from \"@webiny/api-core/features/requestContext/index.js\";\nimport type { EventContext, NextFunction } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-aws/eventTypes/BackgroundTaskEventType.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 { LambdaTimer } from \"~/timer/LambdaTimer.js\";\n\n/* Fallback ceiling used when there is no real Lambda context to read the remaining time from\n * (mirrors the default Lambda timeout budget handler-aws's CustomTimer uses). */\nconst FALLBACK_MAX_RUNNING_MILLISECONDS = 14 * 60 * 1000;\n\nclass BackgroundTaskLambdaHandlerImpl implements BackgroundTaskEventHandler.Interface {\n    constructor(private container: Container) {}\n\n    async execute(\n        eventCtx: EventContext<IBackgroundTaskEvent>,\n        _next: NextFunction\n    ): Promise<unknown> {\n        // Date-based fallback in case there is no real Lambda context (see below) — captured up\n        // front so the fallback countdown starts at the beginning of this invocation.\n        const fallbackStartTime = Date.now();\n        // The SFN/EventBridge transport wraps the task as `{ name, payload }`; TaskRunner expects the\n        // flat task event (webinyTaskId at top level), so unwrap `payload` (falling back to the event\n        // itself if it's already flat).\n        const taskEvent = (eventCtx.event as any)?.payload || eventCtx.event;\n\n        // Background tasks have no HTTP request establisher. This is the bg-task EXTRACT step: put the\n        // tenant id from the task event into RawTenantId, then run the shared LOAD step\n        // (RequestTenantLoader) — same tenant-establishment path as every other transport. The\n        // CRUD (TasksCrud) and downstream use cases resolve the current tenant, so it must be set\n        // before the task runs.\n        if (taskEvent?.tenant) {\n            this.container.resolve(RawTenantId).set(taskEvent.tenant);\n            await this.container.resolve(RequestTenantLoader).establish();\n        }\n\n        // Run the post-context initializers (register TasksCrud, FileModel, etc.). The HTTP layer does\n        // this via RequestContextInitializerDecorator; the bg-task chain must do it too, before the\n        // task runs — otherwise TaskControl can't resolve TasksCrud. continueOnError: a task doesn't\n        // need every HTTP initializer (e.g. ACO/scheduler), and some throw in the bg-task context —\n        // skip+log those so they don't fail the task, while TasksCrud/FileModel still register.\n        await runRequestContextInitializers(this.container, { continueOnError: true });\n\n        // TODO: remove once legacy ctx is gone — resolve services directly from the container.\n        const ctx: Record<string, any> = { container: this.container };\n        for (const enhancer of this.container.resolveAll(GraphQLContextEnhancer)) {\n            await enhancer.enhance(ctx);\n        }\n        for (const schema of this.container.resolveAll(GraphQLContextualSchema)) {\n            await schema.build(ctx);\n        }\n\n        // Use the real Lambda context's countdown when the invocation has one; otherwise fall back\n        // to a Date-based countdown so the timer still winds down instead of staying static.\n        const lambdaContext = this.container.resolve(AwsLambdaContext);\n        const timer = new LambdaTimer({\n            getRemainingTimeInMillis: () => {\n                if (lambdaContext.isSet()) {\n                    return lambdaContext.get().getRemainingTimeInMillis();\n                }\n                return fallbackStartTime + FALLBACK_MAX_RUNNING_MILLISECONDS - Date.now();\n            }\n        });\n        const runner = new TaskRunner(ctx as Context, timer, new TaskEventValidation());\n\n        // Return the task result — the SFN reads `$.status` (continue/done/error) from it to drive\n        // the state machine. Returning void makes the SFN see null → UnknownError → FAILED.\n        return runner.run(taskEvent);\n    }\n}\n\nexport const BackgroundTaskLambdaHandler = BackgroundTaskEventHandler.createImplementation({\n    implementation: BackgroundTaskLambdaHandlerImpl,\n    dependencies: [RequestContainer]\n});\n"],"names":["FALLBACK_MAX_RUNNING_MILLISECONDS","BackgroundTaskLambdaHandlerImpl","container","eventCtx","_next","fallbackStartTime","Date","taskEvent","RawTenantId","RequestTenantLoader","runRequestContextInitializers","ctx","enhancer","GraphQLContextEnhancer","schema","GraphQLContextualSchema","lambdaContext","AwsLambdaContext","timer","LambdaTimer","runner","TaskRunner","TaskEventValidation","BackgroundTaskLambdaHandler","BackgroundTaskEventHandler","RequestContainer"],"mappings":";;;;;;;;AAkBA,MAAMA,oCAAoC;AAE1C,MAAMC;IACF,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;IAAuB;IAE3C,MAAM,QACFC,QAA4C,EAC5CC,KAAmB,EACH;QAGhB,MAAMC,oBAAoBC,KAAK,GAAG;QAIlC,MAAMC,YAAaJ,SAAS,KAAK,EAAU,WAAWA,SAAS,KAAK;QAOpE,IAAII,WAAW,QAAQ;YACnB,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC,aAAa,GAAG,CAACD,UAAU,MAAM;YACxD,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACE,qBAAqB,SAAS;QAC/D;QAOA,MAAMC,8BAA8B,IAAI,CAAC,SAAS,EAAE;YAAE,iBAAiB;QAAK;QAG5E,MAAMC,MAA2B;YAAE,WAAW,IAAI,CAAC,SAAS;QAAC;QAC7D,KAAK,MAAMC,YAAY,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC,wBAC7C,MAAMD,SAAS,OAAO,CAACD;QAE3B,KAAK,MAAMG,UAAU,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC,yBAC3C,MAAMD,OAAO,KAAK,CAACH;QAKvB,MAAMK,gBAAgB,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC;QAC7C,MAAMC,QAAQ,IAAIC,YAAY;YAC1B,0BAA0B;gBACtB,IAAIH,cAAc,KAAK,IACnB,OAAOA,cAAc,GAAG,GAAG,wBAAwB;gBAEvD,OAAOX,oBAAoBL,oCAAoCM,KAAK,GAAG;YAC3E;QACJ;QACA,MAAMc,SAAS,IAAIC,WAAWV,KAAgBO,OAAO,IAAII;QAIzD,OAAOF,OAAO,GAAG,CAACb;IACtB;AACJ;AAEO,MAAMgB,8BAA8BC,2BAA2B,oBAAoB,CAAC;IACvF,gBAAgBvB;IAChB,cAAc;QAACwB;KAAiB;AACpC"}

package/BackgroundTasksAwsFeature.d.ts

@@ -0,0 +1,4 @@
+export declare const BackgroundTasksAwsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/BackgroundTasksAwsFeature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { StepFunctionService } from "./service/StepFunctionService.js";
+import { BackgroundTaskLambdaHandler } from "./BackgroundTaskLambdaHandler.js";
+const BackgroundTasksAwsFeature = createFeature({
+    name: "BackgroundTasksAws",
+    register (container) {
+        container.register(BackgroundTaskLambdaHandler);
+        container.register(StepFunctionService);
+    }
+});
+export { BackgroundTasksAwsFeature };
+
+//# sourceMappingURL=BackgroundTasksAwsFeature.js.map

package/BackgroundTasksAwsFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTasksAwsFeature.js","sources":["../src/BackgroundTasksAwsFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StepFunctionService } from \"~/service/StepFunctionService.js\";\nimport { BackgroundTaskLambdaHandler } from \"~/BackgroundTaskLambdaHandler.js\";\n\nexport const BackgroundTasksAwsFeature = createFeature({\n    name: \"BackgroundTasksAws\",\n    register(container) {\n        container.register(BackgroundTaskLambdaHandler);\n        container.register(StepFunctionService);\n    }\n});\n"],"names":["BackgroundTasksAwsFeature","createFeature","container","BackgroundTaskLambdaHandler","StepFunctionService"],"mappings":";;;AAIO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;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-aws
+
+> [!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/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@webiny/background-tasks-aws",
+	"version": "0.0.0-unstable.0d717d18dd",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "AWS transport for Webiny background tasks (Step Functions, EventBridge, Lambda).",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/background-tasks-aws"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-graphql": "0.0.0-unstable.0d717d18dd",
+		"@webiny/aws-sdk": "0.0.0-unstable.0d717d18dd",
+		"@webiny/background-tasks": "0.0.0-unstable.0d717d18dd",
+		"@webiny/event-handler-aws": "0.0.0-unstable.0d717d18dd",
+		"@webiny/event-handler-core": "0.0.0-unstable.0d717d18dd",
+		"@webiny/feature": "0.0.0-unstable.0d717d18dd",
+		"@webiny/utils": "0.0.0-unstable.0d717d18dd"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0d717d18dd",
+		"@webiny/di": "1.0.2",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.10"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/service/StepFunctionService.d.ts

@@ -0,0 +1,24 @@
+import type { DescribeExecutionCommandOutput } from "@webiny/aws-sdk/client-sfn/index.js";
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+export type IStepFunctionServiceFetchResult = DescribeExecutionCommandOutput;
+export interface IDetailWrapper<T> {
+    detail: T;
+}
+declare class StepFunctionServiceImpl implements TaskService.Interface {
+    private readonly tenantContext;
+    private readonly trigger;
+    private readonly get;
+    constructor(tenantContext: TenantContext.Interface);
+    send(task: TaskService.SendTaskParams, delay: number): Promise<{
+        $metadata: import("@smithy/types").ResponseMetadata;
+        executionArn: string | undefined;
+        startDate: Date | undefined;
+        name: string;
+    } | null>;
+    fetch(task: TaskService.Task): Promise<IStepFunctionServiceFetchResult | null>;
+}
+export declare const StepFunctionService: typeof StepFunctionServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/background-tasks/api/domain/TaskService.js").ITaskService>;
+};
+export {};

package/service/StepFunctionService.js

@@ -0,0 +1,81 @@
+import { createStepFunctionClient, describeExecutionFactory, triggerStepFunctionFactory } from "@webiny/aws-sdk/client-sfn/index.js";
+import { generateAlphaNumericId } from "@webiny/utils";
+import { ServiceDiscovery } from "@webiny/api-core/features/serviceDiscovery/index.js";
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+class StepFunctionServiceImpl {
+    constructor(tenantContext){
+        this.tenantContext = tenantContext;
+        const client = createStepFunctionClient();
+        this.trigger = triggerStepFunctionFactory(client);
+        this.get = describeExecutionFactory(client);
+    }
+    async send(task, delay) {
+        const manifest = await ServiceDiscovery.load();
+        if (!manifest) {
+            console.error("Service manifest not found.");
+            return null;
+        }
+        const { bgTaskSfn } = manifest.api || {};
+        if (!bgTaskSfn) {
+            console.error("Background task state machine not found.");
+            return null;
+        }
+        const tenant = this.tenantContext.getTenant();
+        if (!tenant) {
+            console.error("Tenant not found.");
+            return null;
+        }
+        const input = {
+            webinyTaskId: task.id,
+            webinyTaskDefinitionId: task.definitionId,
+            tenant: tenant.id,
+            delay
+        };
+        const name = `${task.definitionId}_${task.id}_${generateAlphaNumericId(10)}`;
+        try {
+            const result = await this.trigger({
+                input: {
+                    detail: input
+                },
+                stateMachineArn: bgTaskSfn,
+                name
+            });
+            return {
+                ...result,
+                name
+            };
+        } catch (ex) {
+            console.log("Could not trigger a step function.");
+            console.error(ex);
+            return null;
+        }
+    }
+    async fetch(task) {
+        const executionArn = task.eventResponse?.executionArn;
+        if (!executionArn) {
+            console.error(`Execution ARN not found in task "${task.id}".`);
+            return null;
+        }
+        try {
+            const result = await this.get({
+                executionArn
+            });
+            if (!result) return null;
+            return JSON.parse(JSON.stringify(result));
+        } catch (ex) {
+            console.log("Could not get the execution details.");
+            console.error(ex);
+            return null;
+        }
+    }
+}
+const StepFunctionService = TaskService.createImplementation({
+    implementation: StepFunctionServiceImpl,
+    dependencies: [
+        TenantContext
+    ]
+});
+export { StepFunctionService };
+
+//# sourceMappingURL=StepFunctionService.js.map

package/service/StepFunctionService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service/StepFunctionService.js","sources":["../../src/service/StepFunctionService.ts"],"sourcesContent":["import type { DescribeExecutionCommandOutput } from \"@webiny/aws-sdk/client-sfn/index.js\";\nimport {\n    createStepFunctionClient,\n    describeExecutionFactory,\n    triggerStepFunctionFactory\n} from \"@webiny/aws-sdk/client-sfn/index.js\";\nimport type { ITaskEventInput } from \"@webiny/background-tasks/api/handler/types.js\";\nimport { generateAlphaNumericId } from \"@webiny/utils\";\nimport { ServiceDiscovery } from \"@webiny/api-core/features/serviceDiscovery/index.js\";\nimport { TaskService } from \"@webiny/background-tasks/api/domain/TaskService.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\n\nexport type IStepFunctionServiceFetchResult = DescribeExecutionCommandOutput;\n\nexport interface IDetailWrapper<T> {\n    detail: T;\n}\n\nclass StepFunctionServiceImpl implements TaskService.Interface {\n    private readonly trigger;\n    private readonly get;\n\n    public constructor(private readonly tenantContext: TenantContext.Interface) {\n        // TODO client must be injectable at some point via some factory + cache\n        const client = createStepFunctionClient();\n        this.trigger = triggerStepFunctionFactory(client);\n        this.get = describeExecutionFactory(client);\n    }\n    public async send(task: TaskService.SendTaskParams, delay: number) {\n        const manifest = await ServiceDiscovery.load();\n        if (!manifest) {\n            console.error(\"Service manifest not found.\");\n            return null;\n        }\n        const { bgTaskSfn } = manifest.api || {};\n        if (!bgTaskSfn) {\n            console.error(\"Background task state machine not found.\");\n            return null;\n        }\n        const tenant = this.tenantContext.getTenant();\n        if (!tenant) {\n            console.error(\"Tenant not found.\");\n            return null;\n        }\n\n        const input: ITaskEventInput = {\n            webinyTaskId: task.id,\n            webinyTaskDefinitionId: task.definitionId,\n            tenant: tenant.id,\n            delay\n        };\n        const name = `${task.definitionId}_${task.id}_${generateAlphaNumericId(10)}`;\n        try {\n            const result = await this.trigger<IDetailWrapper<ITaskEventInput>>({\n                input: {\n                    detail: input\n                },\n                stateMachineArn: bgTaskSfn,\n                name\n            });\n            return {\n                ...result,\n                name\n            };\n        } catch (ex) {\n            console.log(\"Could not trigger a step function.\");\n            console.error(ex);\n            return null;\n        }\n    }\n\n    public async fetch(task: TaskService.Task): Promise<IStepFunctionServiceFetchResult | null> {\n        const executionArn = task.eventResponse?.executionArn;\n        if (!executionArn) {\n            console.error(`Execution ARN not found in task \"${task.id}\".`);\n            return null;\n        }\n        try {\n            const result = await this.get({\n                executionArn\n            });\n            if (!result) {\n                return null;\n            }\n            return JSON.parse(JSON.stringify(result));\n        } catch (ex) {\n            console.log(\"Could not get the execution details.\");\n            console.error(ex);\n            return null;\n        }\n    }\n}\n\nexport const StepFunctionService = TaskService.createImplementation({\n    implementation: StepFunctionServiceImpl,\n    dependencies: [TenantContext]\n});\n"],"names":["StepFunctionServiceImpl","tenantContext","client","createStepFunctionClient","triggerStepFunctionFactory","describeExecutionFactory","task","delay","manifest","ServiceDiscovery","console","bgTaskSfn","tenant","input","name","generateAlphaNumericId","result","ex","executionArn","JSON","StepFunctionService","TaskService","TenantContext"],"mappings":";;;;;AAkBA,MAAMA;IAIF,YAAoCC,aAAsC,CAAE;aAAxCA,aAAa,GAAbA;QAEhC,MAAMC,SAASC;QACf,IAAI,CAAC,OAAO,GAAGC,2BAA2BF;QAC1C,IAAI,CAAC,GAAG,GAAGG,yBAAyBH;IACxC;IACA,MAAa,KAAKI,IAAgC,EAAEC,KAAa,EAAE;QAC/D,MAAMC,WAAW,MAAMC,iBAAiB,IAAI;QAC5C,IAAI,CAACD,UAAU;YACXE,QAAQ,KAAK,CAAC;YACd,OAAO;QACX;QACA,MAAM,EAAEC,SAAS,EAAE,GAAGH,SAAS,GAAG,IAAI,CAAC;QACvC,IAAI,CAACG,WAAW;YACZD,QAAQ,KAAK,CAAC;YACd,OAAO;QACX;QACA,MAAME,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,IAAI,CAACA,QAAQ;YACTF,QAAQ,KAAK,CAAC;YACd,OAAO;QACX;QAEA,MAAMG,QAAyB;YAC3B,cAAcP,KAAK,EAAE;YACrB,wBAAwBA,KAAK,YAAY;YACzC,QAAQM,OAAO,EAAE;YACjBL;QACJ;QACA,MAAMO,OAAO,GAAGR,KAAK,YAAY,CAAC,CAAC,EAAEA,KAAK,EAAE,CAAC,CAAC,EAAES,uBAAuB,KAAK;QAC5E,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAkC;gBAC/D,OAAO;oBACH,QAAQH;gBACZ;gBACA,iBAAiBF;gBACjBG;YACJ;YACA,OAAO;gBACH,GAAGE,MAAM;gBACTF;YACJ;QACJ,EAAE,OAAOG,IAAI;YACTP,QAAQ,GAAG,CAAC;YACZA,QAAQ,KAAK,CAACO;YACd,OAAO;QACX;IACJ;IAEA,MAAa,MAAMX,IAAsB,EAAmD;QACxF,MAAMY,eAAeZ,KAAK,aAAa,EAAE;QACzC,IAAI,CAACY,cAAc;YACfR,QAAQ,KAAK,CAAC,CAAC,iCAAiC,EAAEJ,KAAK,EAAE,CAAC,EAAE,CAAC;YAC7D,OAAO;QACX;QACA,IAAI;YACA,MAAMU,SAAS,MAAM,IAAI,CAAC,GAAG,CAAC;gBAC1BE;YACJ;YACA,IAAI,CAACF,QACD,OAAO;YAEX,OAAOG,KAAK,KAAK,CAACA,KAAK,SAAS,CAACH;QACrC,EAAE,OAAOC,IAAI;YACTP,QAAQ,GAAG,CAAC;YACZA,QAAQ,KAAK,CAACO;YACd,OAAO;QACX;IACJ;AACJ;AAEO,MAAMG,sBAAsBC,YAAY,oBAAoB,CAAC;IAChE,gBAAgBrB;IAChB,cAAc;QAACsB;KAAc;AACjC"}

package/timer/LambdaTimer.d.ts

@@ -0,0 +1,11 @@
+import type { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+interface LambdaTimerFactory {
+    getRemainingTimeInMillis(): number;
+}
+export declare class LambdaTimer implements Timer.Interface {
+    private readonly factory;
+    constructor(factory: LambdaTimerFactory);
+    getRemainingMilliseconds(): number;
+    getRemainingSeconds(): number;
+}
+export {};

package/timer/LambdaTimer.js

@@ -0,0 +1,14 @@
+class LambdaTimer {
+    constructor(factory){
+        this.factory = factory;
+    }
+    getRemainingMilliseconds() {
+        return this.factory.getRemainingTimeInMillis();
+    }
+    getRemainingSeconds() {
+        return Math.floor(this.getRemainingMilliseconds() / 1000);
+    }
+}
+export { LambdaTimer };
+
+//# sourceMappingURL=LambdaTimer.js.map

package/timer/LambdaTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer/LambdaTimer.js","sources":["../../src/timer/LambdaTimer.ts"],"sourcesContent":["import type { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\n\ninterface LambdaTimerFactory {\n    getRemainingTimeInMillis(): number;\n}\n\nexport class LambdaTimer implements Timer.Interface {\n    private readonly factory: LambdaTimerFactory;\n\n    public constructor(factory: LambdaTimerFactory) {\n        this.factory = factory;\n    }\n\n    public getRemainingMilliseconds(): number {\n        return this.factory.getRemainingTimeInMillis();\n    }\n\n    public getRemainingSeconds(): number {\n        return Math.floor(this.getRemainingMilliseconds() / 1000);\n    }\n}\n"],"names":["LambdaTimer","factory","Math"],"mappings":"AAMO,MAAMA;IAGT,YAAmBC,OAA2B,CAAE;QAC5C,IAAI,CAAC,OAAO,GAAGA;IACnB;IAEO,2BAAmC;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,wBAAwB;IAChD;IAEO,sBAA8B;QACjC,OAAOC,KAAK,KAAK,CAAC,IAAI,CAAC,wBAAwB,KAAK;IACxD;AACJ"}