@webiny/tasks 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/crud/crud.tasks.js

@@ -1,4 +1,4 @@
-import WebinyError from "@webiny/error";
+import error from "@webiny/error";
 import { TaskDataStatus } from "../types.js";
 import { WEBINY_TASK_MODEL_ID } from "./TaskPrivateModel.js";
 import { WEBINY_TASK_LOG_MODEL_ID } from "./TaskLogPrivateModel.js";
@@ -11,368 +11,308 @@ import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/cont
 import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
 import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
-import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
 import { TaskDefinitionNotFoundError, TaskLogNotFoundError, TaskNotFoundError } from "../domain/errors.js";
-import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
 import { TaskAfterCreateEvent, TaskAfterDeleteEvent, TaskAfterUpdateEvent, TaskBeforeCreateEvent, TaskBeforeDeleteEvent, TaskBeforeUpdateEvent } from "../events/index.js";
 import { CmsWhereMapper } from "@webiny/api-headless-cms";
-const createRevisionId = id => {
-  const {
-    id: entryId
-  } = parseIdentifier(id);
-  return `${entryId}#0001`;
+import { createCleanupTaskSubtree } from "./cleanupTaskSubtree.js";
+const createRevisionId = (id)=>{
+    const { id: entryId } = parseIdentifier(id);
+    return `${entryId}#0001`;
 };
-const convertToTask = entry => {
-  return {
-    id: entry.entryId,
-    createdOn: entry.createdOn,
-    savedOn: entry.savedOn,
-    createdBy: entry.createdBy,
-    name: entry.values.name,
-    definitionId: entry.values.definitionId,
-    input: entry.values.input,
-    output: entry.values.output,
-    taskStatus: entry.values.taskStatus,
-    executionName: entry.values.executionName || "",
-    eventResponse: entry.values.eventResponse,
-    startedOn: entry.values.startedOn,
-    finishedOn: entry.values.finishedOn,
-    iterations: entry.values.iterations,
-    parentId: entry.values.parentId
-  };
-};
-const convertToLog = entry => {
-  return {
-    id: entry.entryId,
-    createdOn: entry.createdOn,
-    createdBy: entry.createdBy,
-    executionName: entry.values.executionName,
-    task: entry.values.task,
-    iteration: entry.values.iteration,
-    items: entry.values.items || []
-  };
-};
-const getZodSchema = schema => {
-  if (!schema) {
-    return zod.object({}).passthrough();
-  } else if (schema instanceof zod.ZodObject) {
-    return schema.passthrough();
-  } else if (schema instanceof zod.Schema) {
-    return schema;
-  }
-  return zod.object(schema).passthrough();
-};
-const validateTaskInput = async params => {
-  const {
-    definition,
-    data
-  } = params;
-  if (!definition.createInputValidation) {
-    return;
-  }
-  const schema = definition.createInputValidation({
-    validator: zod
-  });
-  /**
-   * If the schema is not an object, we need to wrap it with the `object` function.
-   */
-  const validate = getZodSchema(schema);
-  const result = await validate.safeParseAsync(data.input);
-  if (result.success) {
-    return;
-  }
-  throw createZodError(result.error);
-};
-export const createTaskCrud = context => {
-  const cmsWhereMapper = context.container.resolve(CmsWhereMapper);
-  const getTaskModel = async () => {
-    const identityContext = context.container.resolve(IdentityContext);
-    return await identityContext.withoutAuthorization(async () => {
-      const getModel = context.container.resolve(GetModelUseCase);
-      const result = await getModel.execute(WEBINY_TASK_MODEL_ID);
-      if (result.isFail()) {
-        throw new WebinyError(`There is no model "${WEBINY_TASK_MODEL_ID}".`);
-      }
-      return result.value;
-    });
-  };
-  const getLogModel = async () => {
-    const identityContext = context.container.resolve(IdentityContext);
-    return await identityContext.withoutAuthorization(async () => {
-      const getModel = context.container.resolve(GetModelUseCase);
-      const result = await getModel.execute(WEBINY_TASK_LOG_MODEL_ID);
-      if (result.isFail()) {
-        throw new WebinyError(`There is no model "${WEBINY_TASK_LOG_MODEL_ID}".`);
-      }
-      return result.value;
+const convertToTask = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        savedOn: entry.savedOn,
+        createdBy: entry.createdBy,
+        name: entry.values.name,
+        definitionId: entry.values.definitionId,
+        input: entry.values.input,
+        output: entry.values.output,
+        taskStatus: entry.values.taskStatus,
+        executionName: entry.values.executionName || "",
+        eventResponse: entry.values.eventResponse,
+        startedOn: entry.values.startedOn,
+        finishedOn: entry.values.finishedOn,
+        iterations: entry.values.iterations,
+        parentId: entry.values.parentId
     });
-  };
-  const getTask = async id => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const entry = await identityContext.withoutAuthorization(async () => {
-      const model = await getTaskModel();
-      const getEntryById = context.container.resolve(GetEntryByIdUseCase);
-      const result = await getEntryById.execute(model, createRevisionId(id));
-      if (result.isFail()) {
-        return null;
-      }
-      return result.value;
+const convertToLog = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        createdBy: entry.createdBy,
+        executionName: entry.values.executionName,
+        task: entry.values.task,
+        iteration: entry.values.iteration,
+        items: entry.values.items || []
     });
-    if (!entry) {
-      return null;
-    }
-    return convertToTask(entry);
-  };
-  const listTasks = async params => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const {
-      entries,
-      meta
-    } = await identityContext.withoutAuthorization(async () => {
-      const model = await getTaskModel();
-      const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
-      const result = await listLatestEntries.execute(model, {
-        ...params,
-        where: cmsWhereMapper.map({
-          input: params?.where,
-          fields: model.fields
-        })
-      });
-      if (result.isFail()) {
-        throw result.error;
-      }
-      return result.value;
+const getZodSchema = (schema)=>{
+    if (!schema) return zod.looseObject({});
+    if (schema instanceof zod.ZodObject) return schema.loose();
+    if (schema instanceof zod.ZodType) return schema;
+    return zod.looseObject(schema);
+};
+const validateTaskInput = async (params)=>{
+    const { definition, data } = params;
+    if (!definition.createInputValidation) return;
+    const schema = definition.createInputValidation({
+        validator: zod
     });
-    return {
-      items: entries.map(item => convertToTask(item)),
-      meta
+    const validate = getZodSchema(schema);
+    const result = await validate.safeParseAsync(data.input);
+    if (result.success) return;
+    throw createZodError(result.error);
+};
+const createTaskCrud = (context)=>{
+    const cmsWhereMapper = context.container.resolve(CmsWhereMapper);
+    const getTaskModel = async ()=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        return await identityContext.withoutAuthorization(async ()=>{
+            const getModel = context.container.resolve(GetModelUseCase);
+            const result = await getModel.execute(WEBINY_TASK_MODEL_ID);
+            if (result.isFail()) throw new error(`There is no model "${WEBINY_TASK_MODEL_ID}".`);
+            return result.value;
+        });
     };
-  };
-  const createTask = async data => {
-    const definition = context.tasks.getDefinition(data.definitionId);
-    if (!definition) {
-      throw new TaskDefinitionNotFoundError(data.definitionId);
-    }
-    await validateTaskInput({
-      context,
-      definition,
-      data
-    });
-    const identityContext = context.container.resolve(IdentityContext);
-    const eventPublisher = context.container.resolve(EventPublisher);
-    const beforeCreateEvent = new TaskBeforeCreateEvent({
-      input: data
-    });
-    await eventPublisher.publish(beforeCreateEvent);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getTaskModel();
-      const createEntry = context.container.resolve(CreateEntryUseCase);
-      return createEntry.execute(model, {
-        values: {
-          ...data,
-          iterations: 0,
-          taskStatus: TaskDataStatus.PENDING
-        }
-      });
-    });
-    if (result.isFail()) {
-      throw result.error;
-    }
-    const task = convertToTask(result.value);
-    const afterCreateEvent = new TaskAfterCreateEvent({
-      input: data,
-      task
-    });
-    await eventPublisher.publish(afterCreateEvent);
-    return task;
-  };
-  const updateTask = async (id, data) => {
-    const original = await getTask(id);
-    if (!original) {
-      throw new TaskNotFoundError();
-    }
-    const identityContext = context.container.resolve(IdentityContext);
-    const eventPublisher = context.container.resolve(EventPublisher);
-    const beforeUpdateEvent = new TaskBeforeUpdateEvent({
-      input: data,
-      original
-    });
-    await eventPublisher.publish(beforeUpdateEvent);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getTaskModel();
-      const updateEntry = context.container.resolve(UpdateEntryUseCase);
-      return updateEntry.execute(model, createRevisionId(id), {
-        values: {
-          ...data
-        }
-      });
-    });
-    if (result.isFail()) {
-      throw result.error;
-    }
-    const task = convertToTask(result.value);
-    const afterUpdateEvent = new TaskAfterUpdateEvent({
-      input: data,
-      task
-    });
-    await eventPublisher.publish(afterUpdateEvent);
-    return task;
-  };
-  const deleteTask = async id => {
-    const task = await getTask(id);
-    if (!task) {
-      throw new TaskNotFoundError();
-    }
-    const identityContext = context.container.resolve(IdentityContext);
-    const eventPublisher = context.container.resolve(EventPublisher);
-    const beforeDeleteEvent = new TaskBeforeDeleteEvent({
-      task
-    });
-    await eventPublisher.publish(beforeDeleteEvent);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getTaskModel();
-      const deleteEntry = context.container.resolve(DeleteEntryUseCase);
-      return deleteEntry.execute(model, createRevisionId(id));
-    });
-    if (result.isFail()) {
-      throw new TaskNotFoundError();
-    }
-    const afterDeleteEvent = new TaskAfterDeleteEvent({
-      task
-    });
-    await eventPublisher.publish(afterDeleteEvent);
-    return true;
-  };
-  const createLog = async (task, data) => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getLogModel();
-      const createEntry = context.container.resolve(CreateEntryUseCase);
-      return createEntry.execute(model, {
-        values: {
-          ...data,
-          task: task.id
+    const getLogModel = async ()=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        return await identityContext.withoutAuthorization(async ()=>{
+            const getModel = context.container.resolve(GetModelUseCase);
+            const result = await getModel.execute(WEBINY_TASK_LOG_MODEL_ID);
+            if (result.isFail()) throw new error(`There is no model "${WEBINY_TASK_LOG_MODEL_ID}".`);
+            return result.value;
+        });
+    };
+    const getTask = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const entry = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const getEntryById = context.container.resolve(GetEntryByIdUseCase);
+            const result = await getEntryById.execute(model, createRevisionId(id));
+            if (result.isFail()) return null;
+            return result.value;
+        });
+        if (!entry) return null;
+        return convertToTask(entry);
+    };
+    const listTasks = async (params)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const { entries, meta } = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                ...params,
+                where: cmsWhereMapper.map({
+                    input: params?.where,
+                    fields: model.fields
+                })
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            items: entries.map((item)=>convertToTask(item)),
+            meta
+        };
+    };
+    const createTask = async (data)=>{
+        const definition = context.tasks.getDefinition(data.definitionId);
+        if (!definition) throw new TaskDefinitionNotFoundError(data.definitionId);
+        await validateTaskInput({
+            context,
+            definition,
+            data
+        });
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeCreateEvent = new TaskBeforeCreateEvent({
+            input: data
+        });
+        await eventPublisher.publish(beforeCreateEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const createEntry = context.container.resolve(CreateEntryUseCase);
+            return createEntry.execute(model, {
+                values: {
+                    ...data,
+                    iterations: 0,
+                    taskStatus: TaskDataStatus.PENDING
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        const task = convertToTask(result.value);
+        const afterCreateEvent = new TaskAfterCreateEvent({
+            input: data,
+            task
+        });
+        await eventPublisher.publish(afterCreateEvent);
+        return task;
+    };
+    const updateTask = async (id, data)=>{
+        const original = await getTask(id);
+        if (!original) throw new TaskNotFoundError();
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeUpdateEvent = new TaskBeforeUpdateEvent({
+            input: data,
+            original
+        });
+        await eventPublisher.publish(beforeUpdateEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const updateEntry = context.container.resolve(UpdateEntryUseCase);
+            return updateEntry.execute(model, createRevisionId(id), {
+                values: {
+                    ...data
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        const task = convertToTask(result.value);
+        const afterUpdateEvent = new TaskAfterUpdateEvent({
+            input: data,
+            task
+        });
+        await eventPublisher.publish(afterUpdateEvent);
+        return task;
+    };
+    const deleteTask = async (id)=>{
+        const task = await getTask(id);
+        if (!task) throw new TaskNotFoundError();
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeDeleteEvent = new TaskBeforeDeleteEvent({
+            task
+        });
+        await eventPublisher.publish(beforeDeleteEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const deleteEntry = context.container.resolve(DeleteEntryUseCase);
+            return deleteEntry.execute(model, createRevisionId(id));
+        });
+        if (result.isFail()) throw new TaskNotFoundError();
+        const afterDeleteEvent = new TaskAfterDeleteEvent({
+            task
+        });
+        await eventPublisher.publish(afterDeleteEvent);
+        return true;
+    };
+    const createLog = async (task, data)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const createEntry = context.container.resolve(CreateEntryUseCase);
+            return createEntry.execute(model, {
+                values: {
+                    ...data,
+                    task: task.id
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        return convertToLog(result.value);
+    };
+    const updateLog = async (id, data)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const updateEntry = context.container.resolve(UpdateEntryUseCase);
+            return updateEntry.execute(model, createRevisionId(id), {
+                values: data
+            });
+        });
+        if (result.isFail()) throw new TaskLogNotFoundError();
+        return convertToLog(result.value);
+    };
+    const deleteLog = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const deleteEntry = context.container.resolve(DeleteEntryUseCase);
+            return deleteEntry.execute(model, id);
+        });
+        if (result.isFail()) throw new TaskLogNotFoundError();
+        return true;
+    };
+    const getLog = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        try {
+            const result = await identityContext.withoutAuthorization(async ()=>{
+                const model = await getLogModel();
+                const getEntryById = context.container.resolve(GetEntryByIdUseCase);
+                return getEntryById.execute(model, id);
+            });
+            if (result.isFail()) throw result.error;
+            return convertToLog(result.value);
+        } catch (ex) {
+            if (ex instanceof NotFoundError) return null;
+            throw ex;
         }
-      });
-    });
-    if (result.isFail()) {
-      throw result.error;
-    }
-    return convertToLog(result.value);
-  };
-  const updateLog = async (id, data) => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getLogModel();
-      const updateEntry = context.container.resolve(UpdateEntryUseCase);
-      return updateEntry.execute(model, createRevisionId(id), {
-        values: data
-      });
-    });
-    if (result.isFail()) {
-      throw new TaskLogNotFoundError();
-    }
-    return convertToLog(result.value);
-  };
-  const deleteLog = async id => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const result = await identityContext.withoutAuthorization(async () => {
-      const model = await getLogModel();
-      const deleteEntry = context.container.resolve(DeleteEntryUseCase);
-      return deleteEntry.execute(model, id);
-    });
-    if (result.isFail()) {
-      throw new TaskLogNotFoundError();
-    }
-    return true;
-  };
-  const getLog = async id => {
-    const identityContext = context.container.resolve(IdentityContext);
-    try {
-      const result = await identityContext.withoutAuthorization(async () => {
-        const model = await getLogModel();
-        const getEntryById = context.container.resolve(GetEntryByIdUseCase);
-        return getEntryById.execute(model, id);
-      });
-      if (result.isFail()) {
-        throw result.error;
-      }
-      return convertToLog(result.value);
-    } catch (ex) {
-      if (ex instanceof NotFoundError) {
-        return null;
-      }
-      throw ex;
-    }
-  };
-  const getLatestLog = async taskId => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const entry = await identityContext.withoutAuthorization(async () => {
-      const model = await getLogModel();
-      const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
-      const result = await listLatestEntries.execute(model, {
-        where: {
-          values: {
-            task: taskId
-          }
-        },
-        sort: ["createdOn_DESC"],
-        limit: 1
-      });
-      if (result.isFail()) {
-        throw result.error;
-      }
-      const {
-        entries
-      } = result.value;
-      const [item] = entries;
-      if (!item) {
-        throw new NotFoundError(`No existing latest log found for task "${taskId}".`);
-      }
-      return item;
-    });
-    return convertToLog(entry);
-  };
-  const listLogs = async params => {
-    const identityContext = context.container.resolve(IdentityContext);
-    const {
-      entries,
-      meta
-    } = await identityContext.withoutAuthorization(async () => {
-      const model = await getLogModel();
-      const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
-      const result = await listLatestEntries.execute(model, {
-        ...params,
-        where: cmsWhereMapper.map({
-          input: params.where,
-          fields: model.fields
-        })
-      });
-      if (result.isFail()) {
-        throw result.error;
-      }
-      return result.value;
-    });
+    };
+    const getLatestLog = async (taskId)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const entry = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                where: {
+                    values: {
+                        task: taskId
+                    }
+                },
+                sort: [
+                    "createdOn_DESC"
+                ],
+                limit: 1
+            });
+            if (result.isFail()) throw result.error;
+            const { entries } = result.value;
+            const [item] = entries;
+            if (!item) throw new NotFoundError(`No existing latest log found for task "${taskId}".`);
+            return item;
+        });
+        return convertToLog(entry);
+    };
+    const cleanupTaskSubtree = createCleanupTaskSubtree(context);
+    const listLogs = async (params)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const { entries, meta } = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                ...params,
+                where: cmsWhereMapper.map({
+                    input: params.where,
+                    fields: model.fields
+                })
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            items: entries.map((item)=>convertToLog(item)),
+            meta
+        };
+    };
     return {
-      items: entries.map(item => convertToLog(item)),
-      meta
+        getTask,
+        listTasks,
+        createTask,
+        updateTask,
+        deleteTask,
+        cleanupTaskSubtree,
+        createLog,
+        updateLog,
+        deleteLog,
+        getLog,
+        listLogs,
+        getLatestLog,
+        getTaskModel,
+        getLogModel
     };
-  };
-  return {
-    getTask,
-    listTasks,
-    createTask,
-    updateTask,
-    deleteTask,
-    createLog,
-    updateLog,
-    deleteLog,
-    getLog,
-    listLogs,
-    getLatestLog,
-    getTaskModel,
-    getLogModel
-  };
 };
+export { createTaskCrud };
 
 //# sourceMappingURL=crud.tasks.js.map