fix(templates): keep the parent task when a subtask fails to apply

createSubtasksFromTemplate rolled back on failure by soft-deleting `parentId`
— which is the *parent* (main) task, not the failed subtask. So any single
subtask-creation error (e.g. the connection-pool P2024) silently deleted the
task the user had just created and verified, and Realtime made it vanish from
their screen ("task disappeared on its own" in OUT-3964). The rollback was also
wrong (it orphaned already-created sibling subtasks) and unnecessary — createTask
already cleans up a half-created subtask via its own catch.

Now each subtemplate is applied best-effort: the whole per-subtemplate unit
(getAppliedTemplateDescription + create) runs inside one try/catch that skips
and logs on failure instead of throwing. Because the handler no longer rejects,
runInBatches never aborts, so every subtemplate is attempted and one failure no
longer skips later batches or returns an error after a partial write (fixes the
two P1 review findings). The parent task is never deleted or orphaned.

Refactored createSubtasksFromTemplate to object params and folded the applied-
description fetch inside it, so both the internal and public call sites share the
same failure isolation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: arpandhakal

src/app/api/tasks/public/public.service.ts

@@ -273,9 +273,13 @@ export class PublicTasksService extends TasksSharedService {
 
       if (template.subTaskTemplates.length) {
         await runInBatches(template.subTaskTemplates, subtaskTemplateBatchSize, async (sub, index) => {
-          const updatedSubTemplate = await templateService.getAppliedTemplateDescription(sub.id)
-          const manualTimeStamp = new Date(template.createdAt.getTime() + (template.subTaskTemplates.length - index) * 10) //maintain the order of subtasks in tasks with respect to subtasks in templates
-          await this.createSubtasksFromTemplate(updatedSubTemplate, newTask, manualTimeStamp)
+          const manualTimestamp = new Date(template.createdAt.getTime() + (template.subTaskTemplates.length - index) * 10) //maintain the order of subtasks in tasks with respect to subtasks in templates
+          await this.createSubtasksFromTemplate({
+            subTemplateId: sub.id,
+            parentTask: newTask,
+            manualTimestamp,
+            templateService,
+          })
         })
       }
     }

src/app/api/tasks/tasks.service.ts

@@ -254,9 +254,13 @@ export class TasksService extends TasksSharedService {
 
       if (template.subTaskTemplates.length) {
         await runInBatches(template.subTaskTemplates, subtaskTemplateBatchSize, async (sub, index) => {
-          const updatedSubTemplate = await templateService.getAppliedTemplateDescription(sub.id)
-          const manualTimeStamp = new Date(template.createdAt.getTime() + (template.subTaskTemplates.length - index) * 10) //maintain the order of subtasks in tasks with respect to subtasks in templates
-          await this.createSubtasksFromTemplate(updatedSubTemplate, newTask, manualTimeStamp)
+          const manualTimestamp = new Date(template.createdAt.getTime() + (template.subTaskTemplates.length - index) * 10) //maintain the order of subtasks in tasks with respect to subtasks in templates
+          await this.createSubtasksFromTemplate({
+            subTemplateId: sub.id,
+            parentTask: newTask,
+            manualTimestamp,
+            templateService,
+          })
         })
       }
     }

src/app/api/tasks/tasksShared.service.ts

@@ -18,10 +18,11 @@ import { SupabaseActions } from '@/utils/SupabaseActions'
 import APIError from '@api/core/exceptions/api'
 import { BaseService } from '@api/core/services/base.service'
 import { UserRole } from '@api/core/types/user'
-import { AssigneeType, Prisma, PrismaClient, StateType, Task, TaskTemplate } from '@prisma/client'
+import { AssigneeType, Prisma, StateType, Task } from '@prisma/client'
 import httpStatus from 'http-status'
 import z from 'zod'
 import { AttachmentsService } from '@api/attachments/attachments.service'
+import type { TemplatesService } from '@api/tasks/templates/templates.service'
 
 //Base class with shared permission logic and methods that both tasks.service.ts and public.service.ts could use
 export abstract class TasksSharedService extends BaseService {
@@ -589,11 +590,22 @@ export abstract class TasksSharedService extends BaseService {
     }
   }
 
-  protected async createSubtasksFromTemplate(data: TaskTemplate, parentTask: Task, manualTimestamp: Date) {
-    const { workspaceId, title, body, workflowStateId } = data
+  protected async createSubtasksFromTemplate({
+    subTemplateId,
+    parentTask,
+    manualTimestamp,
+    templateService,
+  }: {
+    subTemplateId: string
+    parentTask: Task
+    manualTimestamp: Date
+    templateService: TemplatesService
+  }) {
     const { id: parentId, internalUserId, clientId, companyId, associations, isShared } = parentTask
 
     try {
+      const { workspaceId, title, body, workflowStateId } =
+        await templateService.getAppliedTemplateDescription(subTemplateId)
       const createTaskPayload = CreateTaskRequestSchema.parse({
         title: resolveDynamicFields(title),
         body: body ? resolveAutofillTags(body) : body,
@@ -608,23 +620,15 @@ export abstract class TasksSharedService extends BaseService {
         isShared,
       })
 
-      await this.createTask(createTaskPayload, { disableSubtaskTemplates: true, manualTimestamp: manualTimestamp })
+      await this.createTask(createTaskPayload, { disableSubtaskTemplates: true, manualTimestamp })
     } catch (e) {
-      const deleteTask = this.db.task.delete({ where: { id: parentId } })
-      const deleteActivityLogs = this.db.activityLog.deleteMany({ where: { taskId: parentId } })
-
-      await this.db.$transaction(async (tx) => {
-        this.setTransaction(tx as PrismaClient)
-        await deleteTask
-        await deleteActivityLogs
-        this.unsetTransaction()
+      // A failed subtask must never delete or abort the already-created parent task
+      // (previously caused templated tasks to vanish). Skip it; the rest still get created.
+      console.error('TasksSharedService#createSubtasksFromTemplate | Skipping subtask that failed to create', {
+        parentId,
+        subTemplateId,
+        e,
       })
-
-      console.error('TasksService#createTask | Rolling back task creation', e)
-      throw new APIError(
-        httpStatus.INTERNAL_SERVER_ERROR,
-        'Failed to create subtask from template, new task was not created.',
-      )
     }
   }