@webiny/api-core 0.0.0-unstable.0d717d18dd

package/features/task/TaskController/abstractions.d.ts

@@ -0,0 +1,14 @@
+import type { ITaskInput, ITaskOutput } from "../TaskDefinition/index.js";
+/**
+ * TaskController provides runtime capabilities to task definitions.
+ * The actual interface is defined by the tasks package implementation via module augmentation.
+ *
+ * Import this from @webiny/api-core, but the full interface comes from @webiny/tasks.
+ */
+export interface ITaskController<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> {
+}
+/** Runtime controller providing capabilities to running tasks. */
+export declare const TaskController: import("@webiny/di").Abstraction<ITaskController<ITaskInput, ITaskOutput>>;
+export declare namespace TaskController {
+    type Interface<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskController<I, O>;
+}

package/features/task/TaskController/abstractions.js

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

package/features/task/TaskController/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/task/TaskController/abstractions.js","sources":["../../../../src/features/task/TaskController/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ITaskInput, ITaskOutput } from \"../TaskDefinition/index.js\";\n\n/**\n * TaskController provides runtime capabilities to task definitions.\n * The actual interface is defined by the tasks package implementation via module augmentation.\n *\n * Import this from @webiny/api-core, but the full interface comes from @webiny/tasks.\n */\nexport interface ITaskController<\n    // oxlint-disable-next-line typescript/no-unused-vars\n    I extends ITaskInput = ITaskInput,\n    // oxlint-disable-next-line typescript/no-unused-vars\n    O extends ITaskOutput = ITaskOutput\n> {\n    // Empty - augmented by tasks package\n}\n\n/** Runtime controller providing capabilities to running tasks. */\nexport const TaskController = createAbstraction<ITaskController>(\"TaskController\");\n\nexport namespace TaskController {\n    export type Interface<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITaskController<I, O>;\n}\n"],"names":["TaskController","createAbstraction"],"mappings":";AAmBO,MAAMA,iBAAiBC,kBAAmC"}

package/features/task/TaskController/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/task/TaskController/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/task/TaskDefinition/abstractions.d.ts

@@ -0,0 +1,137 @@
+import zod from "zod";
+import type { GenericRecord } from "@webiny/api/types";
+import type { ITask } from "../../../features/task/TaskService/index.js";
+import { TaskController } from "../../../features/task/TaskController/index.js";
+export type ITaskInput = GenericRecord;
+export interface IResponseError {
+    message: string;
+    code?: string | null;
+    data?: GenericRecord | null;
+    stack?: string;
+}
+export interface ITaskOutput {
+    error?: IResponseError;
+    [key: string]: any;
+}
+/**
+ * Task run params - ONLY the input data
+ * All runtime dependencies come from TaskController (injected separately)
+ */
+export interface ITaskRunParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> {
+    input: I;
+    controller: TaskController.Interface<I, O>;
+}
+/**
+ * Data for creating a new task
+ */
+export interface ITaskCreateData<I = ITaskInput> {
+    definitionId: string;
+    name: string;
+    input: I;
+    parentId?: string;
+}
+/**
+ * Parameters for onBeforeTrigger lifecycle hook
+ */
+export interface ITaskBeforeTriggerParams<I = ITaskInput> {
+    data: ITaskCreateData<I>;
+}
+/**
+ * Task result status enum
+ */
+export declare enum TaskResultStatus {
+    DONE = "done",
+    CONTINUE = "continue",
+    ERROR = "error",
+    ABORTED = "aborted"
+}
+/**
+ * Specific result types
+ */
+export interface ITaskResultDone<O extends ITaskOutput = ITaskOutput> {
+    status: TaskResultStatus.DONE;
+    message?: string;
+    output?: O;
+}
+export interface ITaskResultContinue<I = ITaskInput> {
+    status: TaskResultStatus.CONTINUE;
+    input: I;
+    wait?: number;
+}
+export interface ITaskResultError {
+    status: TaskResultStatus.ERROR;
+    error: IResponseError;
+}
+export interface ITaskResultAborted {
+    status: TaskResultStatus.ABORTED;
+}
+export type ITaskResult<I = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskResultDone<O> | ITaskResultContinue<I> | ITaskResultError | ITaskResultAborted;
+export type ISelfCleanupEvent = "onSuccess" | "onError" | "onAbort";
+export type ISelfCleanup = "always" | "never" | ISelfCleanupEvent | ISelfCleanupEvent[];
+export type ITaskLifecycleHook<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = {
+    task: ITask<I, O>;
+};
+/**
+ * Core TaskDefinition - minimal interface
+ */
+export interface ITaskDefinition<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> {
+    id: string;
+    title: string;
+    description?: string;
+    maxIterations?: number;
+    databaseLogs?: boolean;
+    isPrivate?: boolean;
+    selfCleanup?: ISelfCleanup;
+    /**
+     * Core run method - receives ONLY input params
+     * All runtime dependencies (logging, state management, etc.) come from TaskController
+     */
+    run(params: ITaskRunParams<I, O>): Promise<ITaskResult<I, O>>;
+    /**
+     * Optional lifecycle hooks - receive task data, no context.
+     */
+    onBeforeTrigger?(params: ITaskBeforeTriggerParams<I>): Promise<void>;
+    onDone?(params: ITaskLifecycleHook<I, O>): Promise<void>;
+    onError?(params: ITaskLifecycleHook<I, O>): Promise<void>;
+    onAbort?(params: ITaskLifecycleHook<I, O>): Promise<void>;
+    onMaxIterations?(params: ITaskLifecycleHook<I, O>): Promise<void>;
+    /**
+     * Create a validation schema for the task input.
+     * This will be used to validate the input before the task is triggered.
+     */
+    createInputValidation?(params: ITaskCreateInputValidationParams): GenericRecord<keyof I, zod.Schema> | zod.Schema;
+}
+export interface ITaskCreateInputValidationParams {
+    validator: typeof zod;
+}
+/** Define a long-running background task with lifecycle hooks. */
+export declare const TaskDefinition: import("@webiny/di").Abstraction<ITaskDefinition<ITaskInput, ITaskOutput>>;
+/**
+ * IRunnableTaskDefinition represents a TaskDefinition after decoration/processing.
+ * All optional runtime properties are guaranteed to have values (with defaults applied).
+ * Used internally by the task runner to ensure consistent behavior.
+ */
+export interface IRunnableTaskDefinition<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> extends ITaskDefinition<I, O> {
+    isPrivate: boolean;
+    databaseLogs: boolean;
+    maxIterations: number;
+}
+export declare namespace TaskDefinition {
+    type Interface<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskDefinition<I, O>;
+    type TaskInput = ITaskInput;
+    type TaskOutput = ITaskOutput;
+    type Runnable<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = IRunnableTaskDefinition<I, O>;
+    type RunParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskRunParams<I, O>;
+    type Result<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskResult<I, O>;
+    type Task<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITask<I, O>;
+    type ResultDone<O extends ITaskOutput = ITaskOutput> = ITaskResultDone<O>;
+    type ResultContinue<I = ITaskInput> = ITaskResultContinue<I>;
+    type ResultError = ITaskResultError;
+    type ResultAborted = ITaskResultAborted;
+    type CreateInputValidationParams = ITaskCreateInputValidationParams;
+    type TaskCreateData<I = ITaskInput> = ITaskCreateData<I>;
+    type BeforeTriggerParams<I = ITaskInput> = ITaskBeforeTriggerParams<I>;
+    type LifecycleHookParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskLifecycleHook<I, O>;
+    type SelfCleanupEvent = ISelfCleanupEvent;
+    type SelfCleanup = ISelfCleanup;
+}

package/features/task/TaskDefinition/abstractions.js

@@ -0,0 +1,12 @@
+import { createAbstraction } from "@webiny/feature/api";
+var abstractions_TaskResultStatus = /*#__PURE__*/ function(TaskResultStatus) {
+    TaskResultStatus["DONE"] = "done";
+    TaskResultStatus["CONTINUE"] = "continue";
+    TaskResultStatus["ERROR"] = "error";
+    TaskResultStatus["ABORTED"] = "aborted";
+    return TaskResultStatus;
+}({});
+const TaskDefinition = createAbstraction("TaskDefinition");
+export { TaskDefinition, abstractions_TaskResultStatus as TaskResultStatus };
+
+//# sourceMappingURL=abstractions.js.map

package/features/task/TaskDefinition/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/task/TaskDefinition/abstractions.js","sources":["../../../../src/features/task/TaskDefinition/abstractions.ts"],"sourcesContent":["import zod from \"zod\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types\";\nimport type { ITask } from \"~/features/task/TaskService/index.js\";\nimport { TaskController } from \"~/features/task/TaskController/index.js\";\n\nexport type ITaskInput = GenericRecord;\n\nexport interface IResponseError {\n    message: string;\n    code?: string | null;\n    data?: GenericRecord | null;\n    stack?: string;\n}\n\nexport interface ITaskOutput {\n    error?: IResponseError;\n    [key: string]: any;\n}\n\n/**\n * Task run params - ONLY the input data\n * All runtime dependencies come from TaskController (injected separately)\n */\nexport interface ITaskRunParams<\n    I extends ITaskInput = ITaskInput,\n    O extends ITaskOutput = ITaskOutput\n> {\n    input: I;\n    controller: TaskController.Interface<I, O>;\n}\n\n/**\n * Data for creating a new task\n */\nexport interface ITaskCreateData<I = ITaskInput> {\n    definitionId: string;\n    name: string;\n    input: I;\n    parentId?: string;\n}\n\n/**\n * Parameters for onBeforeTrigger lifecycle hook\n */\nexport interface ITaskBeforeTriggerParams<I = ITaskInput> {\n    data: ITaskCreateData<I>;\n}\n\n/**\n * Task result status enum\n */\nexport enum TaskResultStatus {\n    DONE = \"done\",\n    CONTINUE = \"continue\",\n    ERROR = \"error\",\n    ABORTED = \"aborted\"\n}\n\n/**\n * Specific result types\n */\nexport interface ITaskResultDone<O extends ITaskOutput = ITaskOutput> {\n    status: TaskResultStatus.DONE;\n    message?: string;\n    output?: O;\n}\n\nexport interface ITaskResultContinue<I = ITaskInput> {\n    status: TaskResultStatus.CONTINUE;\n    input: I;\n    wait?: number; // seconds to wait before next iteration\n}\n\nexport interface ITaskResultError {\n    status: TaskResultStatus.ERROR;\n    error: IResponseError;\n}\n\nexport interface ITaskResultAborted {\n    status: TaskResultStatus.ABORTED;\n}\n\nexport type ITaskResult<I = ITaskInput, O extends ITaskOutput = ITaskOutput> =\n    | ITaskResultDone<O>\n    | ITaskResultContinue<I>\n    | ITaskResultError\n    | ITaskResultAborted;\n\nexport type ISelfCleanupEvent = \"onSuccess\" | \"onError\" | \"onAbort\";\n\nexport type ISelfCleanup = \"always\" | \"never\" | ISelfCleanupEvent | ISelfCleanupEvent[];\n\nexport type ITaskLifecycleHook<\n    I extends ITaskInput = ITaskInput,\n    O extends ITaskOutput = ITaskOutput\n> = {\n    task: ITask<I, O>;\n};\n\n/**\n * Core TaskDefinition - minimal interface\n */\nexport interface ITaskDefinition<\n    I extends ITaskInput = ITaskInput,\n    O extends ITaskOutput = ITaskOutput\n> {\n    id: string;\n    title: string;\n    description?: string;\n    maxIterations?: number;\n    databaseLogs?: boolean;\n    isPrivate?: boolean;\n    selfCleanup?: ISelfCleanup;\n\n    /**\n     * Core run method - receives ONLY input params\n     * All runtime dependencies (logging, state management, etc.) come from TaskController\n     */\n    run(params: ITaskRunParams<I, O>): Promise<ITaskResult<I, O>>;\n\n    /**\n     * Optional lifecycle hooks - receive task data, no context.\n     */\n    onBeforeTrigger?(params: ITaskBeforeTriggerParams<I>): Promise<void>;\n    onDone?(params: ITaskLifecycleHook<I, O>): Promise<void>;\n    onError?(params: ITaskLifecycleHook<I, O>): Promise<void>;\n    onAbort?(params: ITaskLifecycleHook<I, O>): Promise<void>;\n    onMaxIterations?(params: ITaskLifecycleHook<I, O>): Promise<void>;\n    /**\n     * Create a validation schema for the task input.\n     * This will be used to validate the input before the task is triggered.\n     */\n    createInputValidation?(\n        params: ITaskCreateInputValidationParams\n    ): GenericRecord<keyof I, zod.Schema> | zod.Schema;\n}\n\nexport interface ITaskCreateInputValidationParams {\n    validator: typeof zod;\n}\n\n/** Define a long-running background task with lifecycle hooks. */\nexport const TaskDefinition = createAbstraction<ITaskDefinition>(\"TaskDefinition\");\n\n/**\n * IRunnableTaskDefinition represents a TaskDefinition after decoration/processing.\n * All optional runtime properties are guaranteed to have values (with defaults applied).\n * Used internally by the task runner to ensure consistent behavior.\n */\nexport interface IRunnableTaskDefinition<\n    I extends ITaskInput = ITaskInput,\n    O extends ITaskOutput = ITaskOutput\n> extends ITaskDefinition<I, O> {\n    // Override optional properties to be required with guaranteed values\n    isPrivate: boolean;\n    databaseLogs: boolean;\n    maxIterations: number;\n}\n\nexport namespace TaskDefinition {\n    export type Interface<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITaskDefinition<I, O>;\n\n    export type TaskInput = ITaskInput;\n\n    export type TaskOutput = ITaskOutput;\n\n    export type Runnable<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = IRunnableTaskDefinition<I, O>;\n\n    export type RunParams<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITaskRunParams<I, O>;\n\n    export type Result<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITaskResult<I, O>;\n\n    export type Task<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITask<I, O>;\n\n    export type ResultDone<O extends ITaskOutput = ITaskOutput> = ITaskResultDone<O>;\n    export type ResultContinue<I = ITaskInput> = ITaskResultContinue<I>;\n    export type ResultError = ITaskResultError;\n    export type ResultAborted = ITaskResultAborted;\n    export type CreateInputValidationParams = ITaskCreateInputValidationParams;\n    export type TaskCreateData<I = ITaskInput> = ITaskCreateData<I>;\n    export type BeforeTriggerParams<I = ITaskInput> = ITaskBeforeTriggerParams<I>;\n    export type LifecycleHookParams<\n        I extends ITaskInput = ITaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITaskLifecycleHook<I, O>;\n\n    export type SelfCleanupEvent = ISelfCleanupEvent;\n    export type SelfCleanup = ISelfCleanup;\n}\n"],"names":["TaskResultStatus","TaskDefinition","createAbstraction"],"mappings":";AAoDO,IAAKA,gCAAgBA,WAAAA,GAAAA,SAAhBA,gBAAgB;;;;;WAAhBA;;AA2FL,MAAMC,iBAAiBC,kBAAmC"}

package/features/task/TaskDefinition/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/task/TaskDefinition/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/task/TaskService/abstractions.d.ts

@@ -0,0 +1,75 @@
+import { BaseError, Result } from "@webiny/feature/api";
+import type { GenericRecord } from "@webiny/api/types.js";
+import { type ITaskOutput, TaskDefinition } from "../../../features/task/TaskDefinition/index.js";
+/** Trigger and manage long-running background tasks. */
+export declare const TaskService: import("@webiny/di").Abstraction<ITaskService>;
+export declare namespace TaskService {
+    type Interface = ITaskService;
+    /**
+     * This is the output of `trigger` and `abort` actions.
+     */
+    type GenericOutput = IGenericOutput;
+    type TaskInput = TaskDefinition.TaskInput;
+    type Task<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends ITaskOutput = ITaskOutput> = ITask<I, O>;
+}
+export type IServiceInfo = GenericRecord;
+export interface IResponseError {
+    message: string;
+    code?: string | null;
+    data?: GenericRecord | null;
+    stack?: string;
+}
+export interface ITaskAbortParams {
+    id: string;
+    message?: string;
+}
+export interface ITaskService {
+    trigger: <T extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends IGenericOutput = IGenericOutput>(params: ITaskTriggerParams<T>) => Promise<Result<ITask<T, O>, BaseError>>;
+    abort: <T extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends IGenericOutput = IGenericOutput>(params: ITaskAbortParams) => Promise<Result<ITask<T, O>, BaseError>>;
+    fetchServiceInfo: (input: ITask<any, any> | string) => Promise<Result<IServiceInfo, BaseError>>;
+}
+export interface IGenericOutput {
+    error?: IResponseError;
+    [key: string]: string | string[] | number | boolean | undefined | Record<string, any> | IResponseError;
+}
+export interface ITaskTriggerParams<I = TaskDefinition.TaskInput> {
+    parent?: Pick<ITask, "id">;
+    definition: string;
+    name?: string;
+    input?: I;
+    delay?: number;
+}
+export interface ITaskValues<T = GenericRecord, O extends ITaskOutput = ITaskOutput> {
+    startedOn?: string;
+    finishedOn?: string;
+    eventResponse: GenericRecord | undefined;
+    iterations: number;
+    parentId?: string;
+    name: string;
+    taskStatus: TaskDataStatus;
+    definitionId: string;
+    executionName: string;
+    input: T;
+    output?: O;
+}
+export interface ITask<T = GenericRecord, O extends ITaskOutput = ITaskOutput> extends ITaskValues<T, O> {
+    /**
+     * ID without the revision number (for example: #0001).
+     */
+    id: string;
+    createdOn: string;
+    savedOn: string;
+    createdBy: ITaskIdentity;
+}
+export declare enum TaskDataStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    FAILED = "failed",
+    SUCCESS = "success",
+    ABORTED = "aborted"
+}
+export interface ITaskIdentity {
+    id: string;
+    displayName: string;
+    type: string;
+}

package/features/task/TaskService/abstractions.js

@@ -0,0 +1,13 @@
+import { createAbstraction } from "@webiny/feature/api";
+const TaskService = createAbstraction("TaskService");
+var abstractions_TaskDataStatus = /*#__PURE__*/ function(TaskDataStatus) {
+    TaskDataStatus["PENDING"] = "pending";
+    TaskDataStatus["RUNNING"] = "running";
+    TaskDataStatus["FAILED"] = "failed";
+    TaskDataStatus["SUCCESS"] = "success";
+    TaskDataStatus["ABORTED"] = "aborted";
+    return TaskDataStatus;
+}({});
+export { TaskService, abstractions_TaskDataStatus as TaskDataStatus };
+
+//# sourceMappingURL=abstractions.js.map

package/features/task/TaskService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/task/TaskService/abstractions.js","sources":["../../../../src/features/task/TaskService/abstractions.ts"],"sourcesContent":["import { BaseError, createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { type ITaskOutput, TaskDefinition } from \"~/features/task/TaskDefinition/index.js\";\n\n/** Trigger and manage long-running background tasks. */\nexport const TaskService = createAbstraction<ITaskService>(\"TaskService\");\n\nexport namespace TaskService {\n    export type Interface = ITaskService;\n    /**\n     * This is the output of `trigger` and `abort` actions.\n     */\n    export type GenericOutput = IGenericOutput;\n\n    export type TaskInput = TaskDefinition.TaskInput;\n\n    export type Task<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends ITaskOutput = ITaskOutput\n    > = ITask<I, O>;\n}\n\n// The service info depends on the implementation.\n// We cannot have a more precise type here, since implementation can be anything (AWS, Azure, etc.).\nexport type IServiceInfo = GenericRecord;\n\nexport interface IResponseError {\n    message: string;\n    code?: string | null;\n    data?: GenericRecord | null;\n    stack?: string;\n}\n\nexport interface ITaskAbortParams {\n    id: string;\n    message?: string;\n}\n\nexport interface ITaskService {\n    trigger: <\n        T extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends IGenericOutput = IGenericOutput\n    >(\n        params: ITaskTriggerParams<T>\n    ) => Promise<Result<ITask<T, O>, BaseError>>;\n    abort: <\n        T extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends IGenericOutput = IGenericOutput\n    >(\n        params: ITaskAbortParams\n    ) => Promise<Result<ITask<T, O>, BaseError>>;\n    fetchServiceInfo: (input: ITask<any, any> | string) => Promise<Result<IServiceInfo, BaseError>>;\n}\n\nexport interface IGenericOutput {\n    error?: IResponseError;\n    [key: string]:\n        | string\n        | string[]\n        | number\n        | boolean\n        | undefined\n        | Record<string, any>\n        | IResponseError;\n}\n\nexport interface ITaskTriggerParams<I = TaskDefinition.TaskInput> {\n    parent?: Pick<ITask, \"id\">;\n    definition: string;\n    name?: string;\n    input?: I;\n    delay?: number;\n}\n\nexport interface ITaskValues<T = GenericRecord, O extends ITaskOutput = ITaskOutput> {\n    startedOn?: string;\n    finishedOn?: string;\n    eventResponse: GenericRecord | undefined;\n    iterations: number;\n    parentId?: string;\n    name: string;\n    taskStatus: TaskDataStatus;\n    definitionId: string;\n    executionName: string;\n    input: T;\n    output?: O;\n}\n\nexport interface ITask<T = GenericRecord, O extends ITaskOutput = ITaskOutput> extends ITaskValues<\n    T,\n    O\n> {\n    /**\n     * ID without the revision number (for example: #0001).\n     */\n    id: string;\n    createdOn: string;\n    savedOn: string;\n    createdBy: ITaskIdentity;\n}\n\nexport enum TaskDataStatus {\n    PENDING = \"pending\",\n    RUNNING = \"running\",\n    FAILED = \"failed\",\n    SUCCESS = \"success\",\n    ABORTED = \"aborted\"\n}\n\nexport interface ITaskIdentity {\n    id: string;\n    displayName: string;\n    type: string;\n}\n"],"names":["TaskService","createAbstraction","TaskDataStatus"],"mappings":";AAKO,MAAMA,cAAcC,kBAAgC;AAgGpD,IAAKC,8BAAcA,WAAAA,GAAAA,SAAdA,cAAc;;;;;;WAAdA"}

package/features/task/TaskService/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/task/TaskService/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/tenancy/CreateTenant/CreateTenantGateway.d.ts

@@ -0,0 +1,10 @@
+import { CreateTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+import type { Tenant } from "../../../types/tenancy.js";
+declare class CreateTenantGatewayImpl implements GatewayAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: TenancyStorageOperations.Interface);
+    createTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const CreateTenantGateway: import("@webiny/di").Implementation<typeof CreateTenantGatewayImpl>;
+export {};

package/features/tenancy/CreateTenant/CreateTenantGateway.js

@@ -0,0 +1,21 @@
+import { createImplementation } from "@webiny/di";
+import { CreateTenantGateway } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+class CreateTenantGatewayImpl {
+    constructor(storageOperations){
+        this.storageOperations = storageOperations;
+    }
+    async createTenant(data) {
+        return await this.storageOperations.createTenant(data);
+    }
+}
+const CreateTenantGateway_CreateTenantGateway = createImplementation({
+    abstraction: CreateTenantGateway,
+    implementation: CreateTenantGatewayImpl,
+    dependencies: [
+        TenancyStorageOperations
+    ]
+});
+export { CreateTenantGateway_CreateTenantGateway as CreateTenantGateway };
+
+//# sourceMappingURL=CreateTenantGateway.js.map

package/features/tenancy/CreateTenant/CreateTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/CreateTenantGateway.js","sources":["../../../../src/features/tenancy/CreateTenant/CreateTenantGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { CreateTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { TenancyStorageOperations } from \"../shared/storageOperations.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass CreateTenantGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async createTenant(data: Tenant): Promise<Tenant> {\n        return await this.storageOperations.createTenant(data);\n    }\n}\n\nexport const CreateTenantGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: CreateTenantGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"names":["CreateTenantGatewayImpl","storageOperations","data","CreateTenantGateway","createImplementation","GatewayAbstraction","TenancyStorageOperations"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,iBAAqD,CAAE;aAAvDA,iBAAiB,GAAjBA;IAAwD;IAE5E,MAAM,aAAaC,IAAY,EAAmB;QAC9C,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAACA;IACrD;AACJ;AAEO,MAAMC,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAyB;AAC5C"}

package/features/tenancy/CreateTenant/CreateTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { CreateTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { CreateTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+declare class CreateTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cache;
+    constructor(gateway: CreateTenantGateway.Interface, cache: TenantCache.Interface);
+    create(tenant: Tenant): Promise<Tenant>;
+}
+export declare const CreateTenantRepository: import("@webiny/di").Implementation<typeof CreateTenantRepositoryImpl>;
+export {};

package/features/tenancy/CreateTenant/CreateTenantRepository.js

@@ -0,0 +1,25 @@
+import { createImplementation } from "@webiny/di";
+import { CreateTenantGateway, CreateTenantRepository } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+class CreateTenantRepositoryImpl {
+    constructor(gateway, cache){
+        this.gateway = gateway;
+        this.cache = cache;
+    }
+    async create(tenant) {
+        const created = await this.gateway.createTenant(tenant);
+        this.cache.prime(created.id, created);
+        return created;
+    }
+}
+const CreateTenantRepository_CreateTenantRepository = createImplementation({
+    abstraction: CreateTenantRepository,
+    implementation: CreateTenantRepositoryImpl,
+    dependencies: [
+        CreateTenantGateway,
+        TenantCache
+    ]
+});
+export { CreateTenantRepository_CreateTenantRepository as CreateTenantRepository };
+
+//# sourceMappingURL=CreateTenantRepository.js.map

package/features/tenancy/CreateTenant/CreateTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/CreateTenantRepository.js","sources":["../../../../src/features/tenancy/CreateTenant/CreateTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { CreateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { CreateTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass CreateTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: CreateTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async create(tenant: Tenant) {\n        const created = await this.gateway.createTenant(tenant);\n        this.cache.prime(created.id, created);\n        return created;\n    }\n}\n\nexport const CreateTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: CreateTenantRepositoryImpl,\n    dependencies: [CreateTenantGateway, TenantCache]\n});\n"],"names":["CreateTenantRepositoryImpl","gateway","cache","tenant","created","CreateTenantRepository","createImplementation","RepositoryAbstraction","CreateTenantGateway","TenantCache"],"mappings":";;;AAMA,MAAMA;IACF,YACYC,OAAsC,EACtCC,KAA4B,CACtC;aAFUD,OAAO,GAAPA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,MAAc,EAAE;QACzB,MAAMC,UAAU,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAACD;QAChD,IAAI,CAAC,KAAK,CAAC,KAAK,CAACC,QAAQ,EAAE,EAAEA;QAC7B,OAAOA;IACX;AACJ;AAEO,MAAMC,gDAAyBC,qBAAqB;IACvD,aAAaC;IACb,gBAAgBP;IAChB,cAAc;QAACQ;QAAqBC;KAAY;AACpD"}

package/features/tenancy/CreateTenant/CreateTenantUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { CreateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateTenantRepository } from "./abstractions.js";
+import type { Tenant, CreateTenantInput } from "../../../types/tenancy.js";
+import { CreateTenantError } from "../../../features/tenancy/CreateTenant/errors.js";
+declare class CreateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    constructor(eventPublisher: EventPublisher.Interface, repository: CreateTenantRepository.Interface);
+    execute(data: CreateTenantInput): Promise<Result<never, CreateTenantError> | Result<Tenant, never>>;
+}
+export declare const CreateTenantUseCase: import("@webiny/di").Implementation<typeof CreateTenantUseCaseImpl>;
+export {};

package/features/tenancy/CreateTenant/CreateTenantUseCase.js

@@ -0,0 +1,54 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { mdbid } from "@webiny/utils";
+import { CreateTenantRepository, CreateTenantUseCase } from "./abstractions.js";
+import { TenantAfterCreateEvent, TenantBeforeCreateEvent } from "./events.js";
+import { CreateTenantError } from "./errors.js";
+class CreateTenantUseCaseImpl {
+    constructor(eventPublisher, repository){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(data) {
+        const tenant = {
+            ...data,
+            id: data.id ?? mdbid(),
+            status: "disabled",
+            isInstalled: false,
+            settings: {
+                ...data.settings || {}
+            },
+            savedOn: new Date().toISOString(),
+            createdOn: new Date().toISOString(),
+            parent: data.parent || null
+        };
+        await this.eventPublisher.publish(new TenantBeforeCreateEvent({
+            tenant,
+            input: data
+        }));
+        let createdTenant;
+        try {
+            createdTenant = await this.repository.create(tenant);
+        } catch (e) {
+            return Result.fail(new CreateTenantError({
+                reason: e.message
+            }));
+        }
+        await this.eventPublisher.publish(new TenantAfterCreateEvent({
+            tenant: createdTenant,
+            input: data
+        }));
+        return Result.ok(createdTenant);
+    }
+}
+const CreateTenantUseCase_CreateTenantUseCase = createImplementation({
+    abstraction: CreateTenantUseCase,
+    implementation: CreateTenantUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        CreateTenantRepository
+    ]
+});
+export { CreateTenantUseCase_CreateTenantUseCase as CreateTenantUseCase };
+
+//# sourceMappingURL=CreateTenantUseCase.js.map

package/features/tenancy/CreateTenant/CreateTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/CreateTenantUseCase.js","sources":["../../../../src/features/tenancy/CreateTenant/CreateTenantUseCase.ts"],"sourcesContent":["import { Result, createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { mdbid } from \"@webiny/utils\";\nimport { CreateTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CreateTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeCreateEvent, TenantAfterCreateEvent } from \"./events.js\";\nimport type { Tenant, CreateTenantInput } from \"~/types/tenancy.js\";\nimport { CreateTenantError } from \"~/features/tenancy/CreateTenant/errors.js\";\n\nclass CreateTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisher.Interface,\n        private repository: CreateTenantRepository.Interface\n    ) {}\n\n    async execute(data: CreateTenantInput) {\n        const tenant: Tenant = {\n            ...data,\n            id: data.id ?? mdbid(),\n            status: \"disabled\",\n            isInstalled: false,\n            settings: {\n                ...(data.settings || {})\n            },\n            savedOn: new Date().toISOString(),\n            createdOn: new Date().toISOString(),\n            parent: data.parent || null\n        };\n\n        await this.eventPublisher.publish(new TenantBeforeCreateEvent({ tenant, input: data }));\n\n        let createdTenant: Tenant;\n        try {\n            createdTenant = await this.repository.create(tenant);\n        } catch (e) {\n            return Result.fail(new CreateTenantError({ reason: e.message }));\n        }\n\n        await this.eventPublisher.publish(\n            new TenantAfterCreateEvent({ tenant: createdTenant, input: data })\n        );\n\n        return Result.ok(createdTenant);\n    }\n}\n\nexport const CreateTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: CreateTenantUseCaseImpl,\n    dependencies: [EventPublisher, CreateTenantRepository]\n});\n"],"names":["CreateTenantUseCaseImpl","eventPublisher","repository","data","tenant","mdbid","Date","TenantBeforeCreateEvent","createdTenant","e","Result","CreateTenantError","TenantAfterCreateEvent","CreateTenantUseCase","createImplementation","UseCaseAbstraction","EventPublisher","CreateTenantRepository"],"mappings":";;;;;;AASA,MAAMA;IACF,YACYC,cAAwC,EACxCC,UAA4C,CACtD;aAFUD,cAAc,GAAdA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,IAAuB,EAAE;QACnC,MAAMC,SAAiB;YACnB,GAAGD,IAAI;YACP,IAAIA,KAAK,EAAE,IAAIE;YACf,QAAQ;YACR,aAAa;YACb,UAAU;gBACN,GAAIF,KAAK,QAAQ,IAAI,CAAC,CAAC;YAC3B;YACA,SAAS,IAAIG,OAAO,WAAW;YAC/B,WAAW,IAAIA,OAAO,WAAW;YACjC,QAAQH,KAAK,MAAM,IAAI;QAC3B;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAII,wBAAwB;YAAEH;YAAQ,OAAOD;QAAK;QAEpF,IAAIK;QACJ,IAAI;YACAA,gBAAgB,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACJ;QACjD,EAAE,OAAOK,GAAG;YACR,OAAOC,OAAO,IAAI,CAAC,IAAIC,kBAAkB;gBAAE,QAAQF,EAAE,OAAO;YAAC;QACjE;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIG,uBAAuB;YAAE,QAAQJ;YAAe,OAAOL;QAAK;QAGpE,OAAOO,OAAO,EAAE,CAACF;IACrB;AACJ;AAEO,MAAMK,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBf;IAChB,cAAc;QAACgB;QAAgBC;KAAuB;AAC1D"}

package/features/tenancy/CreateTenant/abstractions.d.ts

@@ -0,0 +1,57 @@
+import { Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant, CreateTenantInput } from "../../../types/tenancy.js";
+import type { TenantBeforeCreatePayload, TenantAfterCreatePayload } from "./events.js";
+import { CreateTenantError } from "./errors.js";
+/**
+ * Errors
+ */
+export interface ICreateTenantErrors {
+    base: CreateTenantError;
+}
+/**
+ * Use Case
+ */
+export interface ICreateTenantUseCase {
+    execute(data: CreateTenantInput): Promise<Result<Tenant, ICreateTenantErrors[keyof ICreateTenantErrors]>>;
+}
+/** Create a new tenant. */
+export declare const CreateTenantUseCase: import("@webiny/di").Abstraction<ICreateTenantUseCase>;
+export declare namespace CreateTenantUseCase {
+    type Interface = ICreateTenantUseCase;
+    type Errors = ICreateTenantErrors[keyof ICreateTenantErrors];
+}
+/**
+ * Repository
+ */
+export interface ICreateTenantRepository {
+    create(tenant: Tenant): Promise<Tenant>;
+}
+/** Persist a newly created tenant. */
+export declare const CreateTenantRepository: import("@webiny/di").Abstraction<ICreateTenantRepository>;
+export declare namespace CreateTenantRepository {
+    type Interface = ICreateTenantRepository;
+}
+/**
+ * Gateway
+ */
+export interface ICreateTenantGateway {
+    createTenant(data: Tenant): Promise<Tenant>;
+}
+/** Storage gateway for tenant creation. */
+export declare const CreateTenantGateway: import("@webiny/di").Abstraction<ICreateTenantGateway>;
+export declare namespace CreateTenantGateway {
+    type Interface = ICreateTenantGateway;
+}
+/** Hook into tenant lifecycle before a tenant is created. */
+export declare const TenantBeforeCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeCreatePayload>>>;
+export declare namespace TenantBeforeCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeCreatePayload>>;
+    type Event = DomainEvent<TenantBeforeCreatePayload>;
+}
+/** Hook into tenant lifecycle after a tenant is created. */
+export declare const TenantAfterCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterCreatePayload>>>;
+export declare namespace TenantAfterCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterCreatePayload>>;
+    type Event = DomainEvent<TenantAfterCreatePayload>;
+}

package/features/tenancy/CreateTenant/abstractions.js

@@ -0,0 +1,9 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CreateTenantUseCase = createAbstraction("CreateTenantUseCase");
+const CreateTenantRepository = createAbstraction("CreateTenantRepository");
+const CreateTenantGateway = createAbstraction("CreateTenantGateway");
+const TenantBeforeCreateEventHandler = createAbstraction("TenantBeforeCreateEventHandler");
+const TenantAfterCreateEventHandler = createAbstraction("TenantAfterCreateEventHandler");
+export { CreateTenantGateway, CreateTenantRepository, CreateTenantUseCase, TenantAfterCreateEventHandler, TenantBeforeCreateEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/CreateTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/abstractions.js","sources":["../../../../src/features/tenancy/CreateTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant, CreateTenantInput } from \"~/types/tenancy.js\";\nimport type { TenantBeforeCreatePayload, TenantAfterCreatePayload } from \"./events.js\";\nimport { CreateTenantError } from \"./errors.js\";\n\n/**\n * Errors\n */\nexport interface ICreateTenantErrors {\n    base: CreateTenantError;\n}\n\n/**\n * Use Case\n */\nexport interface ICreateTenantUseCase {\n    execute(\n        data: CreateTenantInput\n    ): Promise<Result<Tenant, ICreateTenantErrors[keyof ICreateTenantErrors]>>;\n}\n\n/** Create a new tenant. */\nexport const CreateTenantUseCase = createAbstraction<ICreateTenantUseCase>(\"CreateTenantUseCase\");\n\nexport namespace CreateTenantUseCase {\n    export type Interface = ICreateTenantUseCase;\n    export type Errors = ICreateTenantErrors[keyof ICreateTenantErrors];\n}\n\n/**\n * Repository\n */\nexport interface ICreateTenantRepository {\n    create(tenant: Tenant): Promise<Tenant>;\n}\n\n/** Persist a newly created tenant. */\nexport const CreateTenantRepository =\n    createAbstraction<ICreateTenantRepository>(\"CreateTenantRepository\");\n\nexport namespace CreateTenantRepository {\n    export type Interface = ICreateTenantRepository;\n}\n\n/**\n * Gateway\n */\nexport interface ICreateTenantGateway {\n    createTenant(data: Tenant): Promise<Tenant>;\n}\n\n/** Storage gateway for tenant creation. */\nexport const CreateTenantGateway = createAbstraction<ICreateTenantGateway>(\"CreateTenantGateway\");\n\nexport namespace CreateTenantGateway {\n    export type Interface = ICreateTenantGateway;\n}\n\n/** Hook into tenant lifecycle before a tenant is created. */\nexport const TenantBeforeCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeCreatePayload>>\n>(\"TenantBeforeCreateEventHandler\");\n\nexport namespace TenantBeforeCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeCreatePayload>>;\n    export type Event = DomainEvent<TenantBeforeCreatePayload>;\n}\n\n/** Hook into tenant lifecycle after a tenant is created. */\nexport const TenantAfterCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterCreatePayload>>\n>(\"TenantAfterCreateEventHandler\");\n\nexport namespace TenantAfterCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterCreatePayload>>;\n    export type Event = DomainEvent<TenantAfterCreatePayload>;\n}\n"],"names":["CreateTenantUseCase","createAbstraction","CreateTenantRepository","CreateTenantGateway","TenantBeforeCreateEventHandler","TenantAfterCreateEventHandler"],"mappings":";AAuBO,MAAMA,sBAAsBC,kBAAwC;AAepE,MAAMC,yBACTD,kBAA2C;AAcxC,MAAME,sBAAsBF,kBAAwC;AAOpE,MAAMG,iCAAiCH,kBAE5C;AAQK,MAAMI,gCAAgCJ,kBAE3C"}

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.d.ts

@@ -0,0 +1,11 @@
+import { CreateTenantUseCase } from "../abstractions.js";
+import type { CreateTenantInput } from "../../../../types/tenancy.js";
+import { WcpContext } from "../../../../features/wcp/WcpContext/index.js";
+declare class CreateTenantWithWcpIncrementImpl implements CreateTenantUseCase.Interface {
+    private wcp;
+    private decoratee;
+    constructor(wcp: WcpContext.Interface, decoratee: CreateTenantUseCase.Interface);
+    execute(data: CreateTenantInput): Promise<import("@webiny/feature/api").Result<import("~/types/tenancy.js").Tenant, import("../errors.js").CreateTenantError>>;
+}
+export declare const CreateTenantWithWcpIncrement: typeof CreateTenantWithWcpIncrementImpl;
+export {};

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.js

@@ -0,0 +1,25 @@
+import { createDecorator } from "@webiny/feature/api";
+import { CreateTenantUseCase } from "../abstractions.js";
+import { WcpContext } from "../../../wcp/WcpContext/index.js";
+class CreateTenantWithWcpIncrementImpl {
+    constructor(wcp, decoratee){
+        this.wcp = wcp;
+        this.decoratee = decoratee;
+    }
+    async execute(data) {
+        await this.wcp.incrementTenants();
+        const result = await this.decoratee.execute(data);
+        if (result.isFail()) await this.wcp.decrementTenants();
+        return result;
+    }
+}
+const CreateTenantWithWcpIncrement = createDecorator({
+    abstraction: CreateTenantUseCase,
+    decorator: CreateTenantWithWcpIncrementImpl,
+    dependencies: [
+        WcpContext
+    ]
+});
+export { CreateTenantWithWcpIncrement };
+
+//# sourceMappingURL=CreateTenantWithWcpIncrement.js.map

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.js","sources":["../../../../../src/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/feature/api\";\nimport { CreateTenantUseCase } from \"../abstractions.js\";\nimport type { CreateTenantInput } from \"~/types/tenancy.js\";\nimport { WcpContext } from \"~/features/wcp/WcpContext/index.js\";\n\nclass CreateTenantWithWcpIncrementImpl implements CreateTenantUseCase.Interface {\n    constructor(\n        private wcp: WcpContext.Interface,\n        private decoratee: CreateTenantUseCase.Interface\n    ) {}\n\n    async execute(data: CreateTenantInput) {\n        await this.wcp.incrementTenants();\n\n        const result = await this.decoratee.execute(data);\n\n        if (result.isFail()) {\n            await this.wcp.decrementTenants();\n        }\n\n        return result;\n    }\n}\n\nexport const CreateTenantWithWcpIncrement = createDecorator({\n    abstraction: CreateTenantUseCase,\n    decorator: CreateTenantWithWcpIncrementImpl,\n    dependencies: [WcpContext]\n});\n"],"names":["CreateTenantWithWcpIncrementImpl","wcp","decoratee","data","result","CreateTenantWithWcpIncrement","createDecorator","CreateTenantUseCase","WcpContext"],"mappings":";;;AAKA,MAAMA;IACF,YACYC,GAAyB,EACzBC,SAAwC,CAClD;aAFUD,GAAG,GAAHA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,QAAQC,IAAuB,EAAE;QACnC,MAAM,IAAI,CAAC,GAAG,CAAC,gBAAgB;QAE/B,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAE5C,IAAIC,OAAO,MAAM,IACb,MAAM,IAAI,CAAC,GAAG,CAAC,gBAAgB;QAGnC,OAAOA;IACX;AACJ;AAEO,MAAMC,+BAA+BC,gBAAgB;IACxD,aAAaC;IACb,WAAWP;IACX,cAAc;QAACQ;KAAW;AAC9B"}

package/features/tenancy/CreateTenant/errors.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class CreateTenantError extends BaseError {
+    readonly code: "CREATE_TENANT";
+    constructor(data: any);
+}

package/features/tenancy/CreateTenant/errors.js

@@ -0,0 +1,12 @@
+import { BaseError } from "@webiny/feature/api";
+class CreateTenantError extends BaseError {
+    constructor(data){
+        super({
+            message: "Failed to create tenant",
+            data
+        }), this.code = "CREATE_TENANT";
+    }
+}
+export { CreateTenantError };
+
+//# sourceMappingURL=errors.js.map

package/features/tenancy/CreateTenant/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/CreateTenant/errors.js","sources":["../../../../src/features/tenancy/CreateTenant/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class CreateTenantError extends BaseError {\n    override readonly code = \"CREATE_TENANT\" as const;\n\n    constructor(data: any) {\n        super({\n            message: `Failed to create tenant`,\n            data\n        });\n    }\n}\n"],"names":["CreateTenantError","BaseError","data"],"mappings":";AAEO,MAAMA,0BAA0BC;IAGnC,YAAYC,IAAS,CAAE;QACnB,KAAK,CAAC;YACF,SAAS;YACTA;QACJ,SANc,IAAI,GAAG;IAOzB;AACJ"}