@gadmin2n/schematics 0.0.138 → 0.0.140

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

@@ -0,0 +1,46 @@
+import { Injectable, Module, OnModuleInit } from '@nestjs/common';
+import { ExternalInteractionHandlerRegistry } from '../externalInteraction/external-interaction-handler.registry';
+import { ExternalInteractionModule } from '../externalInteraction/externalInteraction.module';
+import { HumanApprovalHandler } from '../externalInteraction/human-approval.handler';
+import { SubjectProviderModule } from '../subjectProvider/subjectProvider.module';
+import { TemporalModule } from '../workflow/temporal.module';
+import { WidgetCatalogService } from '../workflowConfig/widget-catalog.service';
+import { WorkflowConfigModule } from '../workflowConfig/workflowConfig.module';
+import { ApprovalSignalOutboxService } from './approval-signal-outbox.service';
+import { HumanApprovalController } from './human-approval.controller';
+import { HumanApprovalService } from './human-approval.service';
+import { HumanApprovalRuntimeController } from './runtime/human-approval-runtime.controller';
+import { RuntimeTokenGuard } from './runtime/runtime-token.guard';
+
+@Injectable()
+class HumanApprovalWidgetRegistrar implements OnModuleInit {
+  constructor(
+    private readonly widgets: WidgetCatalogService,
+    private readonly handlers: ExternalInteractionHandlerRegistry,
+    private readonly humanApprovalHandler: HumanApprovalHandler,
+  ) {}
+
+  onModuleInit(): void {
+    this.widgets.register('human-approval-config');
+    this.handlers.register(this.humanApprovalHandler);
+  }
+}
+
+@Module({
+  imports: [
+    SubjectProviderModule,
+    TemporalModule,
+    WorkflowConfigModule,
+    ExternalInteractionModule,
+  ],
+  controllers: [HumanApprovalController, HumanApprovalRuntimeController],
+  providers: [
+    HumanApprovalService,
+    ApprovalSignalOutboxService,
+    HumanApprovalWidgetRegistrar,
+    RuntimeTokenGuard,
+    HumanApprovalHandler,
+  ],
+  exports: [HumanApprovalService],
+})
+export class HumanApprovalModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/legacy-approval-config-migration.ts

@@ -0,0 +1,227 @@
+import { ApprovalConfigSnapshotDto } from './human-approval.dto';
+
+type ProviderKey = 'USER' | 'USER_GROUP';
+type MappingEntry = { provider: ProviderKey; ref: string };
+export type ApprovalSubjectMapping = Record<string, MappingEntry>;
+
+export type LegacyApprovalNormalization =
+  | { status: 'READY'; config: ApprovalConfigSnapshotDto }
+  | { status: 'ALREADY_CURRENT'; config: ApprovalConfigSnapshotDto }
+  | { status: 'REQUIRES_MAPPING'; refs: string[] }
+  | { status: 'INVALID'; errors: string[] };
+
+export function normalizeLegacyApprovalConfig(
+  input: unknown,
+  mapping: ApprovalSubjectMapping = {},
+): LegacyApprovalNormalization {
+  if (!isRecord(input)) return invalid('Config must be an object');
+  if (Array.isArray(input.subjects)) {
+    const normalized: Record<string, unknown> = {
+      ...input,
+      subjects: input.subjects.map((subject) =>
+        isRecord(subject) && subject.source === undefined
+          ? { ...subject, source: 'STATIC' }
+          : subject,
+      ),
+    };
+    delete normalized.membershipPolicy;
+    const current = validateCurrent(normalized);
+    return current.length
+      ? { status: 'INVALID', errors: current }
+      : {
+          status:
+            input.membershipPolicy === undefined &&
+            input.subjects.every(
+              (subject) => isRecord(subject) && subject.source !== undefined,
+            )
+              ? 'ALREADY_CURRENT'
+              : 'READY',
+          config: normalized as unknown as ApprovalConfigSnapshotDto,
+        };
+  }
+
+  const subjects = new Map<ProviderKey, string[]>();
+  const add = (provider: ProviderKey, ref: unknown, errors: string[]) => {
+    if (typeof ref !== 'string' || !ref.trim()) {
+      errors.push(`Invalid ${provider} reference`);
+      return;
+    }
+    const refs = subjects.get(provider) ?? [];
+    if (!refs.includes(ref.trim())) refs.push(ref.trim());
+    subjects.set(provider, refs);
+  };
+  const errors: string[] = [];
+  const unresolved: string[] = [];
+
+  for (const ref of array(input.approverUsers)) add('USER', ref, errors);
+  for (const ref of array(input.approverGroups)) add('USER_GROUP', ref, errors);
+  for (const approver of array(input.approvers)) {
+    if (typeof approver === 'string') {
+      const mapped = mapping[approver];
+      if (!mapped) unresolved.push(approver);
+      else add(mapped.provider, mapped.ref, errors);
+      continue;
+    }
+    if (!isRecord(approver)) {
+      errors.push('Invalid approver entry');
+      continue;
+    }
+    const provider =
+      approver.type === 'user'
+        ? 'USER'
+        : approver.type === 'group'
+        ? 'USER_GROUP'
+        : undefined;
+    if (!provider) errors.push('Approver type must be user or group');
+    else add(provider, approver.id, errors);
+  }
+  if (unresolved.length)
+    return {
+      status: 'REQUIRES_MAPPING',
+      refs: [...new Set(unresolved)].sort(),
+    };
+  if (!subjects.size) errors.push('At least one approver is required');
+
+  const approvalRule = normalizeRule(input, errors);
+  const rejectionRule = normalizeExplicitRule(input.rejectionRule, errors) ?? {
+    mode: 'ANY' as const,
+  };
+  const timeout = normalizeTimeout(input, errors);
+  if (errors.length || !approvalRule || !timeout)
+    return { status: 'INVALID', errors };
+
+  return {
+    status: 'READY',
+    config: {
+      subjects: [...subjects].map(([provider, refs]) => ({
+        source: 'STATIC' as const,
+        provider,
+        refs,
+      })),
+      approvalRule,
+      rejectionRule,
+      timeout,
+    },
+  };
+}
+
+function validateCurrent(input: Record<string, unknown>): string[] {
+  const errors: string[] = [];
+  normalizeExplicitRule(input.approvalRule, errors);
+  normalizeExplicitRule(input.rejectionRule, errors);
+  if (!isRecord(input.timeout)) errors.push('Invalid timeout');
+  else {
+    if (!nonNegativeInteger(input.timeout.durationSeconds))
+      errors.push('Invalid timeout durationSeconds');
+    if (!['APPROVED', 'REJECTED'].includes(String(input.timeout.action)))
+      errors.push('Invalid timeout action');
+  }
+  for (const subject of input.subjects as unknown[]) {
+    if (
+      !isRecord(subject) ||
+      !['STATIC', 'DYNAMIC'].includes(String(subject.source)) ||
+      typeof subject.provider !== 'string' ||
+      (subject.source === 'STATIC' &&
+        (!Array.isArray(subject.refs) || subject.refs.length === 0)) ||
+      (subject.source === 'DYNAMIC' &&
+        (typeof subject.inputKey !== 'string' || !subject.inputKey.trim()))
+    )
+      errors.push('Invalid subject');
+  }
+  return errors;
+}
+
+function normalizeRule(input: Record<string, unknown>, errors: string[]) {
+  const explicit = normalizeExplicitRule(input.approvalRule, errors);
+  if (explicit) return explicit;
+  const mode = input.approvalMode ?? 'any';
+  if (mode === 'any') return { mode: 'ANY' as const };
+  if (mode === 'all') return { mode: 'ALL' as const };
+  if (mode === 'percentage') {
+    const percentage = input.minApprovalCount;
+    if (!positiveInteger(percentage) || Number(percentage) > 100) {
+      errors.push(
+        'Percentage approval requires minApprovalCount from 1 to 100',
+      );
+      return undefined;
+    }
+    return { mode: 'PERCENTAGE' as const, percentage: Number(percentage) };
+  }
+  errors.push('Invalid approvalMode');
+  return undefined;
+}
+
+function normalizeExplicitRule(value: unknown, errors: string[]) {
+  if (value === undefined) return undefined;
+  if (!isRecord(value)) {
+    errors.push('Rule must be an object');
+    return undefined;
+  }
+  if (!['ANY', 'ALL', 'COUNT', 'PERCENTAGE'].includes(String(value.mode))) {
+    errors.push('Invalid rule mode');
+    return undefined;
+  }
+  const mode = value.mode as 'ANY' | 'ALL' | 'COUNT' | 'PERCENTAGE';
+  if (mode === 'COUNT' && !positiveInteger(value.count)) {
+    errors.push('COUNT rule requires a positive count');
+    return undefined;
+  }
+  if (
+    mode === 'PERCENTAGE' &&
+    (!positiveInteger(value.percentage) || Number(value.percentage) > 100)
+  ) {
+    errors.push('PERCENTAGE rule requires a percentage from 1 to 100');
+    return undefined;
+  }
+  return {
+    mode,
+    ...(mode === 'COUNT' && { count: Number(value.count) }),
+    ...(mode === 'PERCENTAGE' && {
+      percentage: Number(value.percentage),
+    }),
+  };
+}
+
+function normalizeTimeout(input: Record<string, unknown>, errors: string[]) {
+  if (isRecord(input.timeout)) {
+    if (!nonNegativeInteger(input.timeout.durationSeconds))
+      errors.push('Invalid timeout durationSeconds');
+    if (!['APPROVED', 'REJECTED'].includes(String(input.timeout.action)))
+      errors.push('Invalid timeout action');
+    if (errors.length) return undefined;
+    return {
+      durationSeconds: Number(input.timeout.durationSeconds),
+      action: input.timeout.action as 'APPROVED' | 'REJECTED',
+    };
+  }
+  const durationSeconds = input.timeout ?? 0;
+  if (!nonNegativeInteger(durationSeconds)) {
+    errors.push('Timeout must be a non-negative integer');
+    return undefined;
+  }
+  const legacyAction = input.timeoutAction ?? 'auto_reject';
+  if (!['auto_approve', 'auto_reject'].includes(String(legacyAction))) {
+    errors.push('Legacy timeout action must be auto_approve or auto_reject');
+    return undefined;
+  }
+  return {
+    durationSeconds: Number(durationSeconds),
+    action: legacyAction === 'auto_approve' ? 'APPROVED' : 'REJECTED',
+  } as const;
+}
+
+function invalid(message: string): LegacyApprovalNormalization {
+  return { status: 'INVALID', errors: [message] };
+}
+function array(value: unknown): unknown[] {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+function nonNegativeInteger(value: unknown): boolean {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function positiveInteger(value: unknown): boolean {
+  return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/outbox-retry.util.ts

@@ -0,0 +1,14 @@
+export const OUTBOX_RETRY_CAP_MS = 15 * 60 * 1000;
+
+export function outboxRetryAt(retryCount: number, now = new Date()): Date {
+  const delay = Math.min(
+    OUTBOX_RETRY_CAP_MS,
+    1000 * 2 ** Math.min(Math.max(retryCount, 0), 30),
+  );
+  return new Date(now.getTime() + delay);
+}
+
+export function outboxError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.slice(0, 4000);
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/runtime/human-approval-runtime.controller.ts

@@ -0,0 +1,151 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Get,
+  NotFoundException,
+  Param,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from 'nestjs-prisma';
+import { AllowUnauthorizedRequest } from '../../../lib/auth.guard';
+import { SubmitExternalApprovalDecisionDto } from '../human-approval.dto';
+import { HumanApprovalService } from '../human-approval.service';
+import {
+  StartHumanApprovalRuntimeDto,
+  SubmitApprovalResultRuntimeDto,
+} from './human-approval-runtime.dto';
+import { RuntimeTokenGuard } from './runtime-token.guard';
+
+@Controller('workflow-runtime/human-approval')
+@UseGuards(RuntimeTokenGuard)
+export class HumanApprovalRuntimeController {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly approvals: HumanApprovalService,
+    private readonly config: ConfigService,
+  ) {}
+
+  @Post('start')
+  @AllowUnauthorizedRequest()
+  async start(@Body() input: StartHumanApprovalRuntimeDto) {
+    const runtime = this.config.get<{ tenantNamespace: string }>(
+      'humanApprovalRuntime',
+    );
+    if (input.tenantNamespace !== runtime?.tenantNamespace)
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_TENANT_MISMATCH',
+        message: 'Runtime tenant does not match this application',
+        retryable: false,
+      });
+    const instanceId = parseId(input.workflowInstanceId);
+    const versionId = parseId(input.workflowVersionId);
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+      include: {
+        workflow: { select: { id: true } },
+      },
+    });
+    if (
+      !instance ||
+      instance.versionId !== versionId ||
+      instance.temporalRunId !== input.temporalRunId
+    )
+      throw new NotFoundException({
+        code: 'WORKFLOW_RUNTIME_INSTANCE_NOT_FOUND',
+        message: 'Workflow runtime instance metadata does not match',
+        retryable: false,
+      });
+    const version = await this.prisma.workflowVersion.findUnique({
+      where: { id: versionId },
+      select: { workflowId: true, dsl: true },
+    });
+    const node = (version?.dsl as any)?.nodes?.find(
+      (item: any) => item.id === input.nodeId,
+    );
+    if (
+      !version ||
+      version.workflowId !== instance.workflowId ||
+      node?.runtimeKey !== 'human_approval' ||
+      !node?.source?.configHash ||
+      !node?.config ||
+      typeof node.config !== 'object'
+    )
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
+        message: 'Human Approval input does not match the compiled workflow',
+        retryable: false,
+      });
+    const request = await this.approvals.startRequest(
+      {
+        workflowInstanceId: input.workflowInstanceId,
+        workflowVersionId: input.workflowVersionId,
+        tenantNamespace: input.tenantNamespace,
+        temporalRunId: input.temporalRunId,
+        nodeId: input.nodeId,
+        configHash: node.source.configHash,
+        configSnapshot: node.config,
+        dynamicInputs: input.dynamicInputs,
+        channelInputs: input.channelInputs,
+        resolvedSubjects: input.resolvedSubjects,
+      },
+      { userId: `runtime:${input.tenantNamespace}` },
+    );
+    return {
+      requestId: String(request.id),
+      status: request.status,
+      signalName: 'humanApprovalResolved',
+    };
+  }
+
+  @Get(':requestId/status')
+  @AllowUnauthorizedRequest()
+  status(@Param('requestId') requestId: string) {
+    return this.approvals.status(parseId(requestId));
+  }
+
+  @Post('external-decisions')
+  @AllowUnauthorizedRequest()
+  submitApprovalResult(@Body() input: SubmitApprovalResultRuntimeDto) {
+    const runtime = this.config.get<{ tenantNamespace: string }>(
+      'humanApprovalRuntime',
+    );
+    if (input.tenantNamespace !== runtime?.tenantNamespace)
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_TENANT_MISMATCH',
+        message: 'Runtime tenant does not match this application',
+        retryable: false,
+      });
+    const {
+      requestId,
+      tenantNamespace: _tenantNamespace,
+      workflowInstanceId: _workflowInstanceId,
+      workflowVersionId: _workflowVersionId,
+      temporalRunId: _temporalRunId,
+      nodeId: _nodeId,
+      ...decision
+    } = input;
+    return this.approvals.submitExternalDecision(parseId(requestId), decision);
+  }
+
+  @Post(':requestId/external-decisions')
+  @AllowUnauthorizedRequest()
+  submitExternalDecision(
+    @Param('requestId') requestId: string,
+    @Body() input: SubmitExternalApprovalDecisionDto,
+  ) {
+    return this.approvals.submitExternalDecision(parseId(requestId), input);
+  }
+}
+
+function parseId(value: string): bigint {
+  if (!/^[1-9][0-9]*$/.test(value))
+    throw new BadRequestException({
+      code: 'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
+      message: 'Runtime IDs must be positive integers',
+      retryable: false,
+    });
+  return BigInt(value);
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/runtime/human-approval-runtime.dto.ts

@@ -0,0 +1,88 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsNotEmpty,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import {
+  ResolvedApprovalSubjectDto,
+  SubmitExternalApprovalDecisionDto,
+} from '../human-approval.dto';
+
+export class StartHumanApprovalRuntimeDto {
+  @IsString()
+  @IsNotEmpty()
+  tenantNamespace: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowInstanceId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowVersionId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  nodeId: string;
+
+  // Kept temporarily so older workers can still send these fields. The server
+  // always reads the authoritative config from WorkflowVersion.dsl.
+  @IsOptional()
+  @IsString()
+  instanceVersionId?: string;
+
+  @IsOptional()
+  @IsString()
+  configHash?: string;
+
+  @IsOptional()
+  configSnapshot?: unknown;
+
+  @IsOptional()
+  @IsObject()
+  dynamicInputs?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsObject()
+  channelInputs?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ResolvedApprovalSubjectDto)
+  resolvedSubjects?: ResolvedApprovalSubjectDto[];
+
+  @IsString()
+  @IsNotEmpty()
+  temporalRunId: string;
+}
+
+export class SubmitApprovalResultRuntimeDto extends SubmitExternalApprovalDecisionDto {
+  @IsString()
+  @IsNotEmpty()
+  requestId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  tenantNamespace: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowInstanceId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowVersionId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  temporalRunId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  nodeId: string;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/humanApproval/runtime/runtime-token.guard.ts

@@ -0,0 +1,43 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  ServiceUnavailableException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { timingSafeEqual } from 'crypto';
+
+@Injectable()
+export class RuntimeTokenGuard implements CanActivate {
+  constructor(private readonly config: ConfigService) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const runtime = this.config.get<{
+      enabled: boolean;
+      token: string;
+    }>('humanApprovalRuntime');
+    if (!runtime?.enabled)
+      throw new ServiceUnavailableException({
+        code: 'WORKFLOW_RUNTIME_DISABLED',
+        message: 'Workflow runtime is disabled',
+        retryable: false,
+      });
+    const supplied = context.switchToHttp().getRequest().headers[
+      'x-workflow-runtime-token'
+    ];
+    if (typeof supplied !== 'string' || !safeEqual(supplied, runtime.token))
+      throw new UnauthorizedException({
+        code: 'WORKFLOW_RUNTIME_UNAUTHORIZED',
+        message: 'Invalid workflow runtime token',
+        retryable: false,
+      });
+    return true;
+  }
+}
+
+function safeEqual(left: string, right: string): boolean {
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && timingSafeEqual(a, b);
+}

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

@@ -1,5 +1,25 @@
 import generatedModules from '../generated/modules.index';
+import { ApprovalChannelModule } from './approvalChannel/approvalChannel.module';
 import { CanvasModule } from './canvas/canvas.module';
+import { CodeRuntimeModule } from './codeRuntime/codeRuntime.module';
+import { ExternalInteractionModule } from './externalInteraction/externalInteraction.module';
+import { HttpRequestModule } from './httpRequest/httpRequest.module';
+import { HumanApprovalModule } from './humanApproval/humanApproval.module';
+import { IntegrationConnectionModule } from './integrationConnection/integrationConnection.module';
+import { SubjectProviderModule } from './subjectProvider/subjectProvider.module';
+import { UserGroupModule } from './userGroup/userGroup.module';
 import { WorkflowModule } from './workflow/workflow.module';
 
-export default [...generatedModules, CanvasModule, WorkflowModule];
+export default [
+  ...generatedModules,
+  ApprovalChannelModule,
+  CanvasModule,
+  CodeRuntimeModule,
+  ExternalInteractionModule,
+  HumanApprovalModule,
+  HttpRequestModule,
+  IntegrationConnectionModule,
+  WorkflowModule,
+  SubjectProviderModule,
+  UserGroupModule,
+];

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

@@ -0,0 +1,77 @@
+import { ACGuard } from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { UseRoles } from 'nest-access-control';
+import {
+  actorContextFromRequest,
+  AuthenticatedActorRequest,
+} from '../subjectProvider/actor-context.util';
+import {
+  CreateIntegrationConnectionDto,
+  UpdateIntegrationConnectionDto,
+} from './integration-connection.dto';
+import { IntegrationConnectionService } from './integration-connection.service';
+
+@ApiTags('integration-connections')
+@UseGuards(ACGuard)
+@Controller('integration-connections')
+export class IntegrationConnectionController {
+  constructor(private readonly service: IntegrationConnectionService) {}
+
+  @Get()
+  @UseRoles({
+    resource: 'integrationConnection',
+    action: 'read',
+    possession: 'any',
+  })
+  list(@Query('q') query?: string) {
+    return this.service.list(query?.trim() ?? '');
+  }
+
+  @Get(':code')
+  @UseRoles({
+    resource: 'integrationConnection',
+    action: 'read',
+    possession: 'any',
+  })
+  get(@Param('code') code: string) {
+    return this.service.get(code);
+  }
+
+  @Post()
+  @UseRoles({
+    resource: 'integrationConnection',
+    action: 'create',
+    possession: 'any',
+  })
+  create(
+    @Body() input: CreateIntegrationConnectionDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.create(input, actorContextFromRequest(request));
+  }
+
+  @Patch(':code')
+  @UseRoles({
+    resource: 'integrationConnection',
+    action: 'update',
+    possession: 'any',
+  })
+  update(
+    @Param('code') code: string,
+    @Body() input: UpdateIntegrationConnectionDto,
+    @Req() request: AuthenticatedActorRequest,
+  ) {
+    return this.service.update(code, input, actorContextFromRequest(request));
+  }
+}