@webiny/background-tasks 0.0.0-unstable.0156a4c312

package/api/domain/constants.js

@@ -0,0 +1,6 @@
+const BACKGROUND_TASK_SETTINGS_MODEL_ID = "backgroundTaskSettings";
+const BACKGROUND_TASK_MAX_RETENTION_DAYS = 3650;
+const BACKGROUND_TASK_DEFAULT_RETENTION_DAYS = 90;
+export { BACKGROUND_TASK_DEFAULT_RETENTION_DAYS, BACKGROUND_TASK_MAX_RETENTION_DAYS, BACKGROUND_TASK_SETTINGS_MODEL_ID };
+
+//# sourceMappingURL=constants.js.map

package/api/domain/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/constants.js","sources":["../../../src/api/domain/constants.ts"],"sourcesContent":["export const BACKGROUND_TASK_SETTINGS_MODEL_ID = \"backgroundTaskSettings\";\nexport const BACKGROUND_TASK_MAX_RETENTION_DAYS = 3650;\nexport const BACKGROUND_TASK_DEFAULT_RETENTION_DAYS = 90;\n"],"names":["BACKGROUND_TASK_SETTINGS_MODEL_ID","BACKGROUND_TASK_MAX_RETENTION_DAYS","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS"],"mappings":"AAAO,MAAMA,oCAAoC;AAC1C,MAAMC,qCAAqC;AAC3C,MAAMC,yCAAyC"}

package/api/domain/errors.d.ts

@@ -0,0 +1,61 @@
+import { BaseError } from "@webiny/feature/api";
+import type { ZodError } from "zod";
+import type { ValidationIssue } from "@webiny/utils";
+export declare class TaskDefinitionNotFoundError extends BaseError<{
+    id: string;
+}> {
+    readonly code: "BackgroundTasks/TaskDefinition/NotFoundError";
+    constructor(id: string);
+}
+export declare class TaskNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/Task/NotFoundError";
+    constructor();
+}
+export declare class TaskAbortError extends BaseError<{
+    id: string;
+    status: string;
+}> {
+    readonly code: "BackgroundTasks/Task/Abort";
+    constructor(data: {
+        id: string;
+        status: string;
+    });
+}
+export declare class TaskLogNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/Log/NotFoundError";
+    constructor();
+}
+export declare class TaskServiceInfoError extends BaseError {
+    readonly code: "BackgroundTasks/Service/InfoUnavailable";
+    constructor();
+}
+interface BackgroundTaskValidationErrorData {
+    issues: ValidationIssue[];
+}
+export declare class BackgroundTaskValidationError extends BaseError<BackgroundTaskValidationErrorData> {
+    readonly code: "BackgroundTasks/ValidationError";
+    constructor(error: string | ZodError);
+}
+interface BackgroundTaskPersistenceErrorData {
+    originalMessage: string;
+    originalCode?: string;
+    originalData?: unknown;
+}
+export declare class BackgroundTaskPersistenceError extends BaseError<BackgroundTaskPersistenceErrorData> {
+    readonly code: "BackgroundTasks/PersistenceError";
+    constructor(error: Error);
+    static from(error: unknown): BackgroundTaskPersistenceError;
+}
+export declare class BackgroundTaskModelNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/ModelNotFound";
+    constructor(modelId: string);
+}
+export declare class BackgroundTaskNotAuthorizedError extends BaseError {
+    readonly code: "BackgroundTasks/NotAuthorized";
+    constructor();
+}
+export declare class TaskInputValidationError extends BaseError<Record<string, any>> {
+    readonly code: "VALIDATION_FAILED_INVALID_FIELDS";
+    constructor(error: ZodError);
+}
+export {};

package/api/domain/errors.js

@@ -0,0 +1,109 @@
+import { BaseError } from "@webiny/feature/api";
+import { createZodError, parseZodError } from "@webiny/utils";
+class TaskDefinitionNotFoundError extends BaseError {
+    constructor(id){
+        super({
+            message: "Task definition not found.",
+            data: {
+                id
+            }
+        }), this.code = "BackgroundTasks/TaskDefinition/NotFoundError";
+    }
+}
+class TaskNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "Task not found."
+        }), this.code = "BackgroundTasks/Task/NotFoundError";
+    }
+}
+class TaskAbortError extends BaseError {
+    constructor(data){
+        super({
+            message: "Cannot abort a task that is not pending or running!",
+            data
+        }), this.code = "BackgroundTasks/Task/Abort";
+    }
+}
+class TaskLogNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "Task log not found."
+        }), this.code = "BackgroundTasks/Log/NotFoundError";
+    }
+}
+class TaskServiceInfoError extends BaseError {
+    constructor(){
+        super({
+            message: "Unable to fetch service info."
+        }), this.code = "BackgroundTasks/Service/InfoUnavailable";
+    }
+}
+class BackgroundTaskValidationError extends BaseError {
+    constructor(error){
+        if ("string" == typeof error) super({
+            message: error,
+            data: {
+                issues: []
+            }
+        }), this.code = "BackgroundTasks/ValidationError";
+        else {
+            const issues = parseZodError(error);
+            super({
+                message: "Validation failed.",
+                data: {
+                    issues
+                }
+            }), this.code = "BackgroundTasks/ValidationError";
+        }
+    }
+}
+class BackgroundTaskPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                originalMessage: error.message
+            }
+        }), this.code = "BackgroundTasks/PersistenceError";
+    }
+    static from(error) {
+        if (error instanceof Error) {
+            const instance = new BackgroundTaskPersistenceError(error);
+            const data = {
+                originalMessage: error.message,
+                originalCode: error.code,
+                originalData: error.data
+            };
+            instance.data = data;
+            instance.stack = error.stack;
+            return instance;
+        }
+        return new BackgroundTaskPersistenceError(new Error(String(error)));
+    }
+}
+class BackgroundTaskModelNotFoundError extends BaseError {
+    constructor(modelId){
+        super({
+            message: `Background task model "${modelId}" was not found.`
+        }), this.code = "BackgroundTasks/ModelNotFound";
+    }
+}
+class BackgroundTaskNotAuthorizedError extends BaseError {
+    constructor(){
+        super({
+            message: "Not authorized!"
+        }), this.code = "BackgroundTasks/NotAuthorized";
+    }
+}
+class TaskInputValidationError extends BaseError {
+    constructor(error){
+        super({
+            message: "Validation failed.",
+            data: createZodError(error).data ?? {}
+        }), this.code = "VALIDATION_FAILED_INVALID_FIELDS";
+    }
+}
+export { BackgroundTaskModelNotFoundError, BackgroundTaskNotAuthorizedError, BackgroundTaskPersistenceError, BackgroundTaskValidationError, TaskAbortError, TaskDefinitionNotFoundError, TaskInputValidationError, TaskLogNotFoundError, TaskNotFoundError, TaskServiceInfoError };
+
+//# sourceMappingURL=errors.js.map

package/api/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/errors.js","sources":["../../../src/api/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\nimport type { ZodError } from \"zod\";\nimport { createZodError, parseZodError } from \"@webiny/utils\";\nimport type { ValidationIssue } from \"@webiny/utils\";\n\nexport class TaskDefinitionNotFoundError extends BaseError<{ id: string }> {\n    override readonly code = \"BackgroundTasks/TaskDefinition/NotFoundError\" as const;\n\n    constructor(id: string) {\n        super({\n            message: \"Task definition not found.\",\n            data: {\n                id\n            }\n        });\n    }\n}\n\nexport class TaskNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/Task/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"Task not found.\"\n        });\n    }\n}\n\nexport class TaskAbortError extends BaseError<{ id: string; status: string }> {\n    override readonly code = \"BackgroundTasks/Task/Abort\" as const;\n\n    constructor(data: { id: string; status: string }) {\n        super({\n            message: \"Cannot abort a task that is not pending or running!\",\n            data\n        });\n    }\n}\n\nexport class TaskLogNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/Log/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"Task log not found.\"\n        });\n    }\n}\n\nexport class TaskServiceInfoError extends BaseError {\n    override readonly code = \"BackgroundTasks/Service/InfoUnavailable\" as const;\n\n    constructor() {\n        super({\n            message: \"Unable to fetch service info.\"\n        });\n    }\n}\n\ninterface BackgroundTaskValidationErrorData {\n    issues: ValidationIssue[];\n}\n\nexport class BackgroundTaskValidationError extends BaseError<BackgroundTaskValidationErrorData> {\n    override readonly code = \"BackgroundTasks/ValidationError\" as const;\n\n    constructor(error: string | ZodError) {\n        if (typeof error === \"string\") {\n            super({ message: error, data: { issues: [] } });\n        } else {\n            const issues = parseZodError(error);\n            super({ message: \"Validation failed.\", data: { issues } });\n        }\n    }\n}\n\ninterface BackgroundTaskPersistenceErrorData {\n    originalMessage: string;\n    originalCode?: string;\n    originalData?: unknown;\n}\n\nexport class BackgroundTaskPersistenceError extends BaseError<BackgroundTaskPersistenceErrorData> {\n    override readonly code = \"BackgroundTasks/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { originalMessage: error.message } });\n    }\n\n    static from(error: unknown): BackgroundTaskPersistenceError {\n        if (error instanceof Error) {\n            const instance = new BackgroundTaskPersistenceError(error);\n            const data: BackgroundTaskPersistenceErrorData = {\n                originalMessage: error.message,\n                originalCode: (error as any).code,\n                originalData: (error as any).data\n            };\n            (instance as any).data = data;\n            instance.stack = error.stack;\n            return instance;\n        }\n\n        return new BackgroundTaskPersistenceError(new Error(String(error)));\n    }\n}\n\nexport class BackgroundTaskModelNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/ModelNotFound\" as const;\n\n    constructor(modelId: string) {\n        super({ message: `Background task model \"${modelId}\" was not found.` });\n    }\n}\n\nexport class BackgroundTaskNotAuthorizedError extends BaseError {\n    override readonly code = \"BackgroundTasks/NotAuthorized\" as const;\n\n    constructor() {\n        super({ message: \"Not authorized!\" });\n    }\n}\n\n/*\n * Keeps the code, message and `invalidFields` data that `createZodError` produced before task input\n * validation moved into a use case, so clients that read them see no difference.\n */\nexport class TaskInputValidationError extends BaseError<Record<string, any>> {\n    override readonly code = \"VALIDATION_FAILED_INVALID_FIELDS\" as const;\n\n    constructor(error: ZodError) {\n        super({\n            message: \"Validation failed.\",\n            data: createZodError(error).data ?? {}\n        });\n    }\n}\n"],"names":["TaskDefinitionNotFoundError","BaseError","id","TaskNotFoundError","TaskAbortError","data","TaskLogNotFoundError","TaskServiceInfoError","BackgroundTaskValidationError","error","issues","parseZodError","BackgroundTaskPersistenceError","Error","instance","String","BackgroundTaskModelNotFoundError","modelId","BackgroundTaskNotAuthorizedError","TaskInputValidationError","createZodError"],"mappings":";;AAKO,MAAMA,oCAAoCC;IAG7C,YAAYC,EAAU,CAAE;QACpB,KAAK,CAAC;YACF,SAAS;YACT,MAAM;gBACFA;YACJ;QACJ,SARc,IAAI,GAAG;IASzB;AACJ;AAEO,MAAMC,0BAA0BF;IAGnC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMG,uBAAuBH;IAGhC,YAAYI,IAAoC,CAAE;QAC9C,KAAK,CAAC;YACF,SAAS;YACTA;QACJ,SANc,IAAI,GAAG;IAOzB;AACJ;AAEO,MAAMC,6BAA6BL;IAGtC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMM,6BAA6BN;IAGtC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAMO,MAAMO,sCAAsCP;IAG/C,YAAYQ,KAAwB,CAAE;QAClC,IAAI,AAAiB,YAAjB,OAAOA,OACP,KAAK,CAAC;YAAE,SAASA;YAAO,MAAM;gBAAE,QAAQ,EAAE;YAAC;QAAE,SAJnC,IAAI,GAAG;aAKd;YACH,MAAMC,SAASC,cAAcF;YAC7B,KAAK,CAAC;gBAAE,SAAS;gBAAsB,MAAM;oBAAEC;gBAAO;YAAE,SAP9C,IAAI,GAAG;QAQrB;IACJ;AACJ;AAQO,MAAME,uCAAuCX;IAGhD,YAAYQ,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAE,iBAAiBA,MAAM,OAAO;YAAC;QAAE,SAH3D,IAAI,GAAG;IAIzB;IAEA,OAAO,KAAKA,KAAc,EAAkC;QACxD,IAAIA,iBAAiBI,OAAO;YACxB,MAAMC,WAAW,IAAIF,+BAA+BH;YACpD,MAAMJ,OAA2C;gBAC7C,iBAAiBI,MAAM,OAAO;gBAC9B,cAAeA,MAAc,IAAI;gBACjC,cAAeA,MAAc,IAAI;YACrC;YACCK,SAAiB,IAAI,GAAGT;YACzBS,SAAS,KAAK,GAAGL,MAAM,KAAK;YAC5B,OAAOK;QACX;QAEA,OAAO,IAAIF,+BAA+B,IAAIC,MAAME,OAAON;IAC/D;AACJ;AAEO,MAAMO,yCAAyCf;IAGlD,YAAYgB,OAAe,CAAE;QACzB,KAAK,CAAC;YAAE,SAAS,CAAC,uBAAuB,EAAEA,QAAQ,gBAAgB,CAAC;QAAC,SAHvD,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,yCAAyCjB;IAGlD,aAAc;QACV,KAAK,CAAC;YAAE,SAAS;QAAkB,SAHrB,IAAI,GAAG;IAIzB;AACJ;AAMO,MAAMkB,iCAAiClB;IAG1C,YAAYQ,KAAe,CAAE;QACzB,KAAK,CAAC;YACF,SAAS;YACT,MAAMW,eAAeX,OAAO,IAAI,IAAI,CAAC;QACzC,SANc,IAAI,GAAG;IAOzB;AACJ"}

package/api/domain/task/TaskLogModelProvider.d.ts

@@ -0,0 +1,12 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskLogModelProvider as Abstraction } from "./abstractions.js";
+declare class TaskLogModelProviderImpl implements Abstraction.Interface {
+    private readonly getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const TaskLogModelProvider: typeof TaskLogModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskLogModelProvider>;
+};
+export {};

package/api/domain/task/TaskLogModelProvider.js

@@ -0,0 +1,23 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskLogModelProvider } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError } from "../errors.js";
+import { WEBINY_TASK_LOG_MODEL_ID } from "../../crud/TaskLogPrivateModel.js";
+class TaskLogModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(WEBINY_TASK_LOG_MODEL_ID);
+        if (result.isFail()) throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_LOG_MODEL_ID);
+        return result.value;
+    }
+}
+const TaskLogModelProvider_TaskLogModelProvider = TaskLogModelProvider.createImplementation({
+    implementation: TaskLogModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { TaskLogModelProvider_TaskLogModelProvider as TaskLogModelProvider };
+
+//# sourceMappingURL=TaskLogModelProvider.js.map

package/api/domain/task/TaskLogModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskLogModelProvider.js","sources":["../../../../src/api/domain/task/TaskLogModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { TaskLogModelProvider as Abstraction } from \"./abstractions.js\";\nimport { BackgroundTaskModelNotFoundError } from \"~/api/domain/errors.js\";\nimport { WEBINY_TASK_LOG_MODEL_ID } from \"~/api/crud/TaskLogPrivateModel.js\";\n\nclass TaskLogModelProviderImpl implements Abstraction.Interface {\n    constructor(private readonly getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(WEBINY_TASK_LOG_MODEL_ID);\n        if (result.isFail()) {\n            throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_LOG_MODEL_ID);\n        }\n        return result.value;\n    }\n}\n\nexport const TaskLogModelProvider = Abstraction.createImplementation({\n    implementation: TaskLogModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["TaskLogModelProviderImpl","getModel","result","WEBINY_TASK_LOG_MODEL_ID","BackgroundTaskModelNotFoundError","TaskLogModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;;AAMA,MAAMA;IACF,YAA6BC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAEnE,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAM,IAAIE,iCAAiCD;QAE/C,OAAOD,OAAO,KAAK;IACvB;AACJ;AAEO,MAAMG,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBN;IAChB,cAAc;QAACO;KAAgB;AACnC"}

package/api/domain/task/TaskLogsRepository.d.ts

@@ -0,0 +1,34 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { TaskLogModelProvider, TaskLogsRepository as Abstraction } from "./abstractions.js";
+import { BackgroundTaskPersistenceError, TaskLogNotFoundError } from "../../../api/domain/errors.js";
+declare class TaskLogsRepositoryImpl implements Abstraction.Interface {
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly getEntryById;
+    private readonly listLatestEntries;
+    private readonly createEntry;
+    private readonly updateEntry;
+    private readonly deleteEntry;
+    private readonly whereMapper;
+    constructor(identityContext: IdentityContext.Interface, modelProvider: TaskLogModelProvider.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, createEntry: CreateEntryUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface, deleteEntry: DeleteEntryUseCase.Interface, whereMapper: CmsWhereMapper.Interface);
+    create(task: Parameters<Abstraction.Interface["create"]>[0], data: Parameters<Abstraction.Interface["create"]>[1]): Promise<Result<never, BackgroundTaskPersistenceError> | Result<import("../../types.js").ITaskLog, never>>;
+    update(id: string, data: Parameters<Abstraction.Interface["update"]>[1]): Promise<Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    delete(id: string): Promise<Result<void, never> | Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError>>;
+    get(id: string): Promise<Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    getLatest(taskId: string): Promise<Result<never, BackgroundTaskPersistenceError> | Result<never, TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    list(params: Parameters<Abstraction.Interface["list"]>[0]): Promise<Result<never, BackgroundTaskPersistenceError> | Result<{
+        items: import("../../types.js").ITaskLog[];
+        meta: import("@webiny/api-headless-cms/types/types.js").CmsEntryMeta;
+    }, never>>;
+}
+export declare const TaskLogsRepository: typeof TaskLogsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskLogsRepository>;
+};
+export {};

package/api/domain/task/TaskLogsRepository.js

@@ -0,0 +1,146 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { TaskLogModelProvider, TaskLogsRepository } from "./abstractions.js";
+import { entryToTaskLog } from "./entryToTaskLog.js";
+import { createRevisionId } from "./createRevisionId.js";
+import { BackgroundTaskPersistenceError, TaskLogNotFoundError } from "../errors.js";
+const ENTRY_NOT_FOUND = "Cms/Entry/NotFound";
+const toLogError = (error)=>{
+    if (error.code === ENTRY_NOT_FOUND) return new TaskLogNotFoundError();
+    return BackgroundTaskPersistenceError.from(error);
+};
+class TaskLogsRepositoryImpl {
+    constructor(identityContext, modelProvider, getEntryById, listLatestEntries, createEntry, updateEntry, deleteEntry, whereMapper){
+        this.identityContext = identityContext;
+        this.modelProvider = modelProvider;
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.createEntry = createEntry;
+        this.updateEntry = updateEntry;
+        this.deleteEntry = deleteEntry;
+        this.whereMapper = whereMapper;
+    }
+    async create(task, data) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.createEntry.execute(model, {
+                    values: {
+                        ...data,
+                        task: task.id
+                    }
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            return Result.ok(entryToTaskLog(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async update(id, data) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.updateEntry.execute(model, createRevisionId(id), {
+                    values: data
+                });
+            });
+            if (result.isFail()) return Result.fail(toLogError(result.error));
+            return Result.ok(entryToTaskLog(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async delete(id) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.deleteEntry.execute(model, id);
+            });
+            if (result.isFail()) return Result.fail(toLogError(result.error));
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async get(id) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.getEntryById.execute(model, id);
+            });
+            if (result.isFail()) return Result.fail(toLogError(result.error));
+            return Result.ok(entryToTaskLog(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async getLatest(taskId) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.listLatestEntries.execute(model, {
+                    where: {
+                        values: {
+                            task: taskId
+                        }
+                    },
+                    sort: [
+                        "createdOn_DESC"
+                    ],
+                    limit: 1
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            const [entry] = result.value.entries;
+            if (!entry) return Result.fail(new TaskLogNotFoundError());
+            return Result.ok(entryToTaskLog(entry));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async list(params) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.listLatestEntries.execute(model, {
+                    ...params,
+                    where: this.whereMapper.map({
+                        input: params.where,
+                        fields: model.fields
+                    })
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            const { entries, meta } = result.value;
+            return Result.ok({
+                items: entries.map((entry)=>entryToTaskLog(entry)),
+                meta
+            });
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const TaskLogsRepository_TaskLogsRepository = TaskLogsRepository.createImplementation({
+    implementation: TaskLogsRepositoryImpl,
+    dependencies: [
+        IdentityContext,
+        TaskLogModelProvider,
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        CreateEntryUseCase,
+        UpdateEntryUseCase,
+        DeleteEntryUseCase,
+        CmsWhereMapper
+    ]
+});
+export { TaskLogsRepository_TaskLogsRepository as TaskLogsRepository };
+
+//# sourceMappingURL=TaskLogsRepository.js.map

package/api/domain/task/TaskLogsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskLogsRepository.js","sources":["../../../../src/api/domain/task/TaskLogsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { TaskLogModelProvider, TaskLogsRepository as Abstraction } from \"./abstractions.js\";\nimport { entryToTaskLog } from \"./entryToTaskLog.js\";\nimport { createRevisionId } from \"./createRevisionId.js\";\nimport { BackgroundTaskPersistenceError, TaskLogNotFoundError } from \"~/api/domain/errors.js\";\n\nconst ENTRY_NOT_FOUND = \"Cms/Entry/NotFound\";\n\nconst toLogError = (error: {\n    code?: string;\n}): TaskLogNotFoundError | BackgroundTaskPersistenceError => {\n    if (error.code === ENTRY_NOT_FOUND) {\n        return new TaskLogNotFoundError();\n    }\n    return BackgroundTaskPersistenceError.from(error);\n};\n\n/*\n * Task logs are stored as entries of a private CMS model, and like tasks, they're read and written\n * without authorization.\n */\nclass TaskLogsRepositoryImpl implements Abstraction.Interface {\n    constructor(\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly modelProvider: TaskLogModelProvider.Interface,\n        private readonly getEntryById: GetEntryByIdUseCase.Interface,\n        private readonly listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private readonly createEntry: CreateEntryUseCase.Interface,\n        private readonly updateEntry: UpdateEntryUseCase.Interface,\n        private readonly deleteEntry: DeleteEntryUseCase.Interface,\n        private readonly whereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async create(\n        task: Parameters<Abstraction.Interface[\"create\"]>[0],\n        data: Parameters<Abstraction.Interface[\"create\"]>[1]\n    ) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.createEntry.execute(model, {\n                    values: {\n                        ...data,\n                        task: task.id\n                    }\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            return Result.ok(entryToTaskLog(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async update(id: string, data: Parameters<Abstraction.Interface[\"update\"]>[1]) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.updateEntry.execute(model, createRevisionId(id), {\n                    values: data\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(toLogError(result.error));\n            }\n            return Result.ok(entryToTaskLog(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async delete(id: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.deleteEntry.execute(model, id);\n            });\n            if (result.isFail()) {\n                return Result.fail(toLogError(result.error));\n            }\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async get(id: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.getEntryById.execute(model, id);\n            });\n            if (result.isFail()) {\n                return Result.fail(toLogError(result.error));\n            }\n            return Result.ok(entryToTaskLog(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async getLatest(taskId: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.listLatestEntries.execute(model, {\n                    where: {\n                        values: {\n                            task: taskId\n                        }\n                    },\n                    sort: [\"createdOn_DESC\"],\n                    limit: 1\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            const [entry] = result.value.entries;\n            if (!entry) {\n                return Result.fail(new TaskLogNotFoundError());\n            }\n            return Result.ok(entryToTaskLog(entry));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async list(params: Parameters<Abstraction.Interface[\"list\"]>[0]) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.listLatestEntries.execute(model, {\n                    ...params,\n                    where: this.whereMapper.map({\n                        input: params.where,\n                        fields: model.fields\n                    })\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            const { entries, meta } = result.value;\n            return Result.ok({\n                items: entries.map(entry => entryToTaskLog(entry)),\n                meta\n            });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const TaskLogsRepository = Abstraction.createImplementation({\n    implementation: TaskLogsRepositoryImpl,\n    dependencies: [\n        IdentityContext,\n        TaskLogModelProvider,\n        GetEntryByIdUseCase,\n        ListLatestEntriesUseCase,\n        CreateEntryUseCase,\n        UpdateEntryUseCase,\n        DeleteEntryUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ENTRY_NOT_FOUND","toLogError","error","TaskLogNotFoundError","BackgroundTaskPersistenceError","TaskLogsRepositoryImpl","identityContext","modelProvider","getEntryById","listLatestEntries","createEntry","updateEntry","deleteEntry","whereMapper","task","data","result","model","Result","entryToTaskLog","id","createRevisionId","taskId","entry","params","entries","meta","TaskLogsRepository","Abstraction","IdentityContext","TaskLogModelProvider","GetEntryByIdUseCase","ListLatestEntriesUseCase","CreateEntryUseCase","UpdateEntryUseCase","DeleteEntryUseCase","CmsWhereMapper"],"mappings":"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"}

package/api/domain/task/TaskModelProvider.d.ts

@@ -0,0 +1,12 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskModelProvider as Abstraction } from "./abstractions.js";
+declare class TaskModelProviderImpl implements Abstraction.Interface {
+    private readonly getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const TaskModelProvider: typeof TaskModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskModelProvider>;
+};
+export {};

package/api/domain/task/TaskModelProvider.js

@@ -0,0 +1,23 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskModelProvider } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError } from "../errors.js";
+import { WEBINY_TASK_MODEL_ID } from "../../crud/TaskPrivateModel.js";
+class TaskModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(WEBINY_TASK_MODEL_ID);
+        if (result.isFail()) throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_MODEL_ID);
+        return result.value;
+    }
+}
+const TaskModelProvider_TaskModelProvider = TaskModelProvider.createImplementation({
+    implementation: TaskModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { TaskModelProvider_TaskModelProvider as TaskModelProvider };
+
+//# sourceMappingURL=TaskModelProvider.js.map

package/api/domain/task/TaskModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskModelProvider.js","sources":["../../../../src/api/domain/task/TaskModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { TaskModelProvider as Abstraction } from \"./abstractions.js\";\nimport { BackgroundTaskModelNotFoundError } from \"~/api/domain/errors.js\";\nimport { WEBINY_TASK_MODEL_ID } from \"~/api/crud/TaskPrivateModel.js\";\n\nclass TaskModelProviderImpl implements Abstraction.Interface {\n    constructor(private readonly getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(WEBINY_TASK_MODEL_ID);\n        if (result.isFail()) {\n            throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_MODEL_ID);\n        }\n        return result.value;\n    }\n}\n\nexport const TaskModelProvider = Abstraction.createImplementation({\n    implementation: TaskModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["TaskModelProviderImpl","getModel","result","WEBINY_TASK_MODEL_ID","BackgroundTaskModelNotFoundError","TaskModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;;AAMA,MAAMA;IACF,YAA6BC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAEnE,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAM,IAAIE,iCAAiCD;QAE/C,OAAOD,OAAO,KAAK;IACvB;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAgC,CAAC;IAC9D,gBAAgBN;IAChB,cAAc;QAACO;KAAgB;AACnC"}

package/api/domain/task/TasksRepository.d.ts

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { TaskModelProvider, TasksRepository as Abstraction } from "./abstractions.js";
+import { BackgroundTaskPersistenceError, TaskNotFoundError } from "../../../api/domain/errors.js";
+import type { IListTaskParams, ITaskCreateData, ITaskUpdateData } from "../../../api/types.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+type TaskInput = TaskService.TaskInput;
+type TaskOutput = TaskService.GenericOutput;
+declare class TasksRepositoryImpl implements Abstraction.Interface {
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly getEntryById;
+    private readonly listLatestEntries;
+    private readonly createEntry;
+    private readonly updateEntry;
+    private readonly deleteEntry;
+    private readonly whereMapper;
+    constructor(identityContext: IdentityContext.Interface, modelProvider: TaskModelProvider.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, createEntry: CreateEntryUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface, deleteEntry: DeleteEntryUseCase.Interface, whereMapper: CmsWhereMapper.Interface);
+    get<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string): Promise<Result<never, BackgroundTaskPersistenceError | TaskNotFoundError> | Result<TaskService.Task<I, O>, never>>;
+    list<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(params?: IListTaskParams): Promise<Result<never, BackgroundTaskPersistenceError> | Result<{
+        items: TaskService.Task<I, O>[];
+        meta: import("@webiny/api-headless-cms/types/types.js").CmsEntryMeta;
+    }, never>>;
+    create<I extends TaskInput = TaskInput>(data: ITaskCreateData<I>): Promise<Result<never, BackgroundTaskPersistenceError> | Result<TaskService.Task<I, import("@webiny/api-core/features/task/TaskService/abstractions.js").IGenericOutput>, never>>;
+    update<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string, data: Partial<ITaskUpdateData<I, O>>): Promise<Result<never, BackgroundTaskPersistenceError | TaskNotFoundError> | Result<TaskService.Task<I, O>, never>>;
+    delete(id: string): Promise<Result<void, never> | Result<never, BackgroundTaskPersistenceError | TaskNotFoundError>>;
+}
+export declare const TasksRepository: typeof TasksRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITasksRepository>;
+};
+export {};