@gadmin2n/schematics 0.0.150 → 0.0.152

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-lifecycle.service.ts

@@ -0,0 +1,125 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma, WorkflowInstanceStatus } from '@prisma/client';
+import { PrismaService } from 'nestjs-prisma';
+
+export interface MarkWorkflowInstanceFailedInput {
+  instanceId: bigint;
+  expectedStatuses: WorkflowInstanceStatus[];
+  temporalRunId?: string | null;
+  result: Prisma.InputJsonValue;
+  startedAt?: Date;
+  finishedAt?: Date;
+}
+
+export interface WorkflowFailureCallback {
+  connectionRef: string;
+  path: string;
+}
+
+@Injectable()
+export class WorkflowLifecycleService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async markFailed(input: MarkWorkflowInstanceFailedInput): Promise<boolean> {
+    return this.prisma.$transaction(async (tx) => {
+      const failedAt = input.finishedAt ?? new Date();
+      const updated = await tx.workflowInstance.updateMany({
+        where: {
+          id: input.instanceId,
+          status: { in: input.expectedStatuses },
+          ...(input.temporalRunId !== undefined && {
+            temporalRunId: input.temporalRunId,
+          }),
+        },
+        data: {
+          status: 'FAILED',
+          result: input.result,
+          ...(input.startedAt && { startedAt: input.startedAt }),
+          finishedAt: failedAt,
+        },
+      });
+      if (updated.count !== 1) return false;
+
+      const instance = await tx.workflowInstance.findUniqueOrThrow({
+        where: { id: input.instanceId },
+        select: {
+          versionId: true,
+          sourceOutboxId: true,
+          workflow: { select: { code: true } },
+        },
+      });
+      if (instance.sourceOutboxId === null) return true;
+
+      const version = await tx.workflowVersion.findUniqueOrThrow({
+        where: { id: instance.versionId },
+        select: { dsl: true },
+      });
+      const callback = extractWorkflowFailureCallback(version.dsl);
+      if (!callback) return true;
+
+      const source = await tx.workflowEventOutbox.findUnique({
+        where: { id: instance.sourceOutboxId },
+        select: {
+          schemaName: true,
+          tableName: true,
+          operation: true,
+          primaryKey: true,
+        },
+      });
+      if (!source)
+        throw new Error(
+          `Workflow event ${instance.sourceOutboxId} was not found for lifecycle notification`,
+        );
+
+      const eventKey = `workflow-instance:${input.instanceId}:FAILED`;
+      await tx.workflowLifecycleOutbox.upsert({
+        where: { eventKey },
+        create: {
+          eventKey,
+          workflowInstanceId: input.instanceId,
+          eventType: 'FAILED',
+          workflowCode: instance.workflow.code,
+          businessReference: {
+            schema: source.schemaName,
+            table: source.tableName,
+            operation: source.operation,
+            primaryKey: source.primaryKey,
+          },
+          connectionRef: callback.connectionRef,
+          callbackPath: callback.path,
+          failedAt,
+        },
+        update: {},
+      });
+      return true;
+    });
+  }
+}
+
+export function extractWorkflowFailureCallback(
+  dsl: unknown,
+): WorkflowFailureCallback | null {
+  const nodes = asRecord(dsl).nodes;
+  if (!Array.isArray(nodes)) return null;
+  const trigger = nodes
+    .map(asRecord)
+    .find((node) => node.type === 'event_trigger');
+  if (!trigger) return null;
+  const config = asRecord(trigger.config);
+  if (config.failureCallback === undefined) return null;
+  const callback = asRecord(config.failureCallback);
+  const connectionRef =
+    typeof callback.connectionRef === 'string'
+      ? callback.connectionRef.trim()
+      : '';
+  const path = typeof callback.path === 'string' ? callback.path.trim() : '';
+  if (!connectionRef || !path.startsWith('/'))
+    throw new Error('WORKFLOW_FAILURE_CALLBACK_CONFIG_INVALID');
+  return { connectionRef, path };
+}
+
+function asRecord(value: unknown): Record<string, any> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, any>)
+    : {};
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-node-type.controller.ts

@@ -1,15 +1,21 @@
+import { ACGuard } from '@gadmin2n/nest-common';
 import { Controller, Get, UseGuards } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
-import AuthGuard from '../../lib/auth.guard';
+import { UseRoles } from 'nest-access-control';
 import { WorkflowNodeTypeService } from './workflow-node-type.service';
 
-@ApiTags('workflow-node-types')
-@UseGuards(AuthGuard)
+@UseGuards(ACGuard)
 @Controller('workflow-node-types')
+@ApiTags('workflow-node-types')
 export class WorkflowNodeTypeController {
   constructor(private readonly service: WorkflowNodeTypeService) {}
 
   @Get()
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   findAll() {
     return this.service.findAll();
   }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.controller.ts

@@ -22,6 +22,7 @@ import { UseRoles } from 'nest-access-control';
 import { PrismaService } from 'nestjs-prisma';
 import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import { TemporalService } from './temporal.service';
+import { listWorkflowDatabaseFunctions } from './workflow-database-function';
 import {
   ApproveInstanceDto,
   ExecuteWorkflowDto,
@@ -43,8 +44,9 @@ import {
 } from './workflow.dto';
 import { WorkflowService } from './workflow.service';
 
-@ApiTags('workflow')
+@UseGuards(ACGuard)
 @Controller('workflow')
+@ApiTags('workflow')
 export class WorkflowController {
   constructor(
     private readonly workflowService: WorkflowService,
@@ -55,6 +57,11 @@ export class WorkflowController {
   ) {}
 
   @Get()
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   findAll(@Query() query: WorkflowListQueryDto) {
     return this.workflowService.findMany({
       status: query.status,
@@ -66,7 +73,6 @@ export class WorkflowController {
   }
 
   @Post('event-catalog/register')
-  @UseGuards(ACGuard)
   @UseRoles({
     resource: 'workflowEventRegistration',
     action: 'create',
@@ -77,31 +83,71 @@ export class WorkflowController {
   }
 
   @Get('overview')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   getOverview() {
     return this.workflowService.getOverview();
   }
 
   @Get('callable')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   findCallable() {
     return this.workflowService.findCallableWorkflows();
   }
 
   @Get('external-interaction-options')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   findExternalInteractionOptions() {
     return this.workflowService.findExternalInteractionOptions();
   }
 
+  @Get('database-functions')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
+  findDatabaseFunctions() {
+    return listWorkflowDatabaseFunctions(this.prisma);
+  }
+
   @Get('event-catalog/overview')
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'read',
+    possession: 'any',
+  })
   findBusinessEventCatalogOverview() {
     return this.workflowService.findBusinessEventCatalogOverview();
   }
 
   @Get('event-catalog/sources')
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'read',
+    possession: 'any',
+  })
   findBusinessEventSources() {
     return this.workflowService.findBusinessEventSources();
   }
 
   @Get('event-catalog/:registrationCode/instances')
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'read',
+    possession: 'any',
+  })
   findBusinessEventInstances(
     @Param('registrationCode') registrationCode: string,
     @Query() query: WorkflowInstanceListQueryDto,
@@ -114,7 +160,6 @@ export class WorkflowController {
   }
 
   @Post('event-catalog/unregister')
-  @UseGuards(ACGuard)
   @UseRoles({
     resource: 'workflowEventRegistration',
     action: 'delete',
@@ -125,6 +170,11 @@ export class WorkflowController {
   }
 
   @Get('event-catalog')
+  @UseRoles({
+    resource: 'workflowEventRegistration',
+    action: 'read',
+    possession: 'any',
+  })
   findBusinessEventCatalog() {
     return this.workflowService.findBusinessEventCatalog();
   }
@@ -132,6 +182,11 @@ export class WorkflowController {
   // ─── Export/Import Endpoints ──────────────────────────────────────────────────
 
   @Post(':id/export-token')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   async generateExportToken(@Param('id', ParseIntPipe) id: number, @Req() req) {
     const baseUrl = `${req.protocol}://${req.get('host')}/api`;
     return this.workflowExportService.generateExportToken(BigInt(id), baseUrl);
@@ -150,11 +205,21 @@ export class WorkflowController {
   }
 
   @Post('import-preview')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   async importPreview(@Body() dto: ImportPayloadDto) {
     return this.workflowExportService.importPreview(dto.payload);
   }
 
   @Post('import-confirm')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
     return this.workflowExportService.importConfirm(
       dto.payload,
@@ -163,16 +228,31 @@ export class WorkflowController {
   }
 
   @Post()
+  @UseRoles({
+    resource: 'workflow',
+    action: 'create',
+    possession: 'any',
+  })
   create(@Req() req, @Body() dto: CreateWorkflowDto) {
     return this.workflowService.create(dto, req.user.userid);
   }
 
   @Get(':id')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   findOne(@Param('id', ParseIntPipe) id: number) {
     return this.workflowService.findOne(BigInt(id));
   }
 
   @Patch(':id')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   update(
     @Param('id', ParseIntPipe) id: number,
     @Body() dto: UpdateWorkflowDto,
@@ -181,11 +261,21 @@ export class WorkflowController {
   }
 
   @Patch(':id/save')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   saveDraft(@Param('id', ParseIntPipe) id: number, @Body() dto: SaveDraftDto) {
     return this.workflowService.saveDraft(BigInt(id), dto.dsl);
   }
 
   @Patch(':id/toggle')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   toggleEnabled(
     @Param('id', ParseIntPipe) id: number,
     @Body() dto: ToggleEnabledDto,
@@ -194,16 +284,31 @@ export class WorkflowController {
   }
 
   @Delete(':id')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'delete',
+    possession: 'any',
+  })
   remove(@Param('id', ParseIntPipe) id: number) {
     return this.workflowService.remove(BigInt(id));
   }
 
   @Get(':id/versions')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   getVersions(@Param('id', ParseIntPipe) id: number) {
     return this.workflowService.getVersions(BigInt(id));
   }
 
   @Get(':id/versions/:version')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   getVersionDsl(
     @Param('id', ParseIntPipe) id: number,
     @Param('version', ParseIntPipe) version: number,
@@ -212,6 +317,11 @@ export class WorkflowController {
   }
 
   @Post(':id/publish')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'update',
+    possession: 'any',
+  })
   publish(
     @Param('id', ParseIntPipe) id: number,
     @Req() req,
@@ -221,6 +331,11 @@ export class WorkflowController {
   }
 
   @Get(':id/instances')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'read',
+    possession: 'any',
+  })
   getInstances(
     @Param('id', ParseIntPipe) id: number,
     @Query() query: WorkflowInstanceListQueryDto,
@@ -233,6 +348,11 @@ export class WorkflowController {
   }
 
   @Get(':id/stats')
+  @UseRoles({
+    resource: 'workflow',
+    action: 'read',
+    possession: 'any',
+  })
   getStats(@Param('id', ParseIntPipe) id: number) {
     return this.workflowService.getStats(BigInt(id));
   }
@@ -240,7 +360,6 @@ export class WorkflowController {
   // ─── Execution Endpoints ──────────────────────────────────────────────────────
 
   @Post('actions/:code/execute')
-  @UseGuards(ACGuard)
   @UseRoles({
     resource: 'workflowExecution',
     action: 'create',
@@ -261,6 +380,11 @@ export class WorkflowController {
   }
 
   @Get('instance/:instanceId')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'read',
+    possession: 'any',
+  })
   getInstanceDetail(
     @Param('instanceId', ParseIntPipe) instanceId: number,
     @Req() req,
@@ -272,6 +396,11 @@ export class WorkflowController {
   }
 
   @Post('instance/:instanceId/cancel')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'update',
+    possession: 'any',
+  })
   async cancelInstance(
     @Param('instanceId', ParseIntPipe) instanceId: number,
     @Req() req,
@@ -286,6 +415,11 @@ export class WorkflowController {
   }
 
   @Post('instance/:instanceId/retry')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'update',
+    possession: 'any',
+  })
   async retryInstance(
     @Param('instanceId', ParseIntPipe) instanceId: number,
     @Req() req,
@@ -298,6 +432,11 @@ export class WorkflowController {
   }
 
   @Post('instance/:instanceId/retry-from-node')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'update',
+    possession: 'any',
+  })
   async retryInstanceFromNode(
     @Param('instanceId', ParseIntPipe) instanceId: number,
     @Body() dto: RetryFromNodeDto,
@@ -312,6 +451,11 @@ export class WorkflowController {
   }
 
   @Post('instance/:instanceId/approve')
+  @UseRoles({
+    resource: 'workflowExecution',
+    action: 'update',
+    possession: 'any',
+  })
   async approveInstance(
     @Param('instanceId', ParseIntPipe) instanceId: number,
     @Body() dto: ApproveInstanceDto,

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.module.ts

@@ -1,11 +1,15 @@
 import { Module } from '@nestjs/common';
 import { HttpRequestModule } from '../httpRequest/httpRequest.module';
 import { HumanApprovalModule } from '../humanApproval/humanApproval.module';
+import { IntegrationConnectionModule } from '../integrationConnection/integrationConnection.module';
 import { UserModule } from '../user/user.module';
 import { WorkflowConfigModule } from '../workflowConfig/workflowConfig.module';
 import { TemporalModule } from './temporal.module';
 import { WorkflowCompilerService } from './workflow-compiler.service';
 import { WorkflowExportService } from './workflow-export.service';
+import { WorkflowLifecycleOutboxService } from './workflow-lifecycle-outbox.service';
+import { WorkflowLifecycleRuntimeController } from './workflow-lifecycle-runtime.controller';
+import { WorkflowLifecycleService } from './workflow-lifecycle.service';
 import { WorkflowNodeTypeController } from './workflow-node-type.controller';
 import { WorkflowNodeTypeService } from './workflow-node-type.service';
 import { WorkflowRuntimeFacade } from './workflow-runtime.facade';
@@ -18,15 +22,22 @@ import { WorkflowService } from './workflow.service';
     TemporalModule,
     HumanApprovalModule,
     HttpRequestModule,
+    IntegrationConnectionModule,
     WorkflowConfigModule,
   ],
-  controllers: [WorkflowController, WorkflowNodeTypeController],
+  controllers: [
+    WorkflowController,
+    WorkflowNodeTypeController,
+    WorkflowLifecycleRuntimeController,
+  ],
   providers: [
     WorkflowService,
     WorkflowNodeTypeService,
     WorkflowExportService,
     WorkflowCompilerService,
     WorkflowRuntimeFacade,
+    WorkflowLifecycleService,
+    WorkflowLifecycleOutboxService,
   ],
   exports: [WorkflowService, WorkflowCompilerService, WorkflowRuntimeFacade],
 })

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.service.spec.ts

@@ -5,6 +5,7 @@ import { HumanApprovalService } from '../humanApproval/human-approval.service';
 import { TemporalService } from './temporal.service';
 import { signWebhookPayload } from './webhook-signature.util';
 import { WorkflowCompilerService } from './workflow-compiler.service';
+import { WorkflowLifecycleService } from './workflow-lifecycle.service';
 import { WorkflowService } from './workflow.service';
 
 describe('WorkflowService — workflow list run counts', () => {
@@ -37,6 +38,7 @@ describe('WorkflowService — workflow list run counts', () => {
       {} as any,
       {} as any,
       {} as any,
+      {} as any,
     );
 
     const result = await service.findMany({});
@@ -152,6 +154,10 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         { provide: TemporalService, useValue: temporal },
         { provide: HumanApprovalService, useValue: {} },
         { provide: WorkflowCompilerService, useValue: compiler },
+        {
+          provide: WorkflowLifecycleService,
+          useValue: { markFailed: jest.fn() },
+        },
       ],
     }).compile();
 
@@ -1563,6 +1569,10 @@ describe('WorkflowService — receiveWebhook', () => {
           provide: WorkflowCompilerService,
           useValue: { compile: jest.fn(async (dsl: any) => dsl) },
         },
+        {
+          provide: WorkflowLifecycleService,
+          useValue: { markFailed: jest.fn() },
+        },
       ],
     }).compile();
 
@@ -1815,6 +1825,10 @@ describe('WorkflowService — approveInstance', () => {
         { provide: TemporalService, useValue: temporal },
         { provide: HumanApprovalService, useValue: humanApproval },
         { provide: WorkflowCompilerService, useValue: {} },
+        {
+          provide: WorkflowLifecycleService,
+          useValue: { markFailed: jest.fn() },
+        },
       ],
     }).compile();
     service = module.get(WorkflowService);