@codemation/host 0.0.1

package/src/application/commands/SetPinnedNodeInputCommandHandler.ts

@@ -0,0 +1,50 @@
+import { ItemsInputNormalizer, inject, type PersistedRunState } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import { SetPinnedNodeInputCommand } from "./SetPinnedNodeInputCommand";
+
+@HandlesCommand.forCommand(SetPinnedNodeInputCommand)
+export class SetPinnedNodeInputCommandHandler extends CommandHandler<SetPinnedNodeInputCommand, PersistedRunState> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+    @inject(ItemsInputNormalizer)
+    private readonly itemsInputNormalizer: ItemsInputNormalizer,
+  ) {
+    super();
+  }
+
+  async execute(command: SetPinnedNodeInputCommand): Promise<PersistedRunState> {
+    const state = await this.workflowRunRepository.load(command.runId);
+    if (!state) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    if (!state.executionOptions?.isMutable) {
+      throw new ApplicationRequestError(403, `Run ${state.runId} is immutable`);
+    }
+    const decodedNodeId = decodeURIComponent(command.nodeId);
+    const pinnedItems =
+      command.body.items == null ? undefined : this.itemsInputNormalizer.normalize(command.body.items);
+    const nextNodesById = {
+      ...(state.mutableState?.nodesById ?? {}),
+      [decodedNodeId]: {
+        ...(state.mutableState?.nodesById?.[decodedNodeId] ?? {}),
+        pinnedOutputsByPort: pinnedItems ? { main: pinnedItems } : undefined,
+      },
+    };
+    await this.workflowRunRepository.save({
+      ...state,
+      mutableState: {
+        nodesById: nextNodesById,
+      },
+    });
+    const updated = await this.workflowRunRepository.load(state.runId);
+    if (!updated) {
+      throw new ApplicationRequestError(404, "Unknown runId");
+    }
+    return updated;
+  }
+}

package/src/application/commands/SetWorkflowActivationCommand.ts

@@ -0,0 +1,10 @@
+import { Command } from "../bus/Command";
+
+export class SetWorkflowActivationCommand extends Command<Readonly<{ active: boolean }>> {
+  constructor(
+    public readonly workflowId: string,
+    public readonly active: boolean,
+  ) {
+    super();
+  }
+}

package/src/application/commands/SetWorkflowActivationCommandHandler.ts

@@ -0,0 +1,39 @@
+import { inject } from "@codemation/core";
+import { Engine } from "@codemation/core/bootstrap";
+import { ApplicationTokens } from "../../applicationTokens";
+import { WorkflowActivationPreflight } from "../../domain/workflows/WorkflowActivationPreflight";
+import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
+import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { CommandHandler } from "../bus/CommandHandler";
+import { SetWorkflowActivationCommand } from "./SetWorkflowActivationCommand";
+
+@HandlesCommand.forCommand(SetWorkflowActivationCommand)
+export class SetWorkflowActivationCommandHandler extends CommandHandler<
+  SetWorkflowActivationCommand,
+  Readonly<{ active: boolean }>
+> {
+  constructor(
+    @inject(ApplicationTokens.WorkflowActivationRepository)
+    private readonly workflowActivationRepository: WorkflowActivationRepository,
+    @inject(RuntimeWorkflowActivationPolicy)
+    private readonly workflowActivationPolicy: RuntimeWorkflowActivationPolicy,
+    @inject(Engine)
+    private readonly engine: Engine,
+    @inject(WorkflowActivationPreflight)
+    private readonly workflowActivationPreflight: WorkflowActivationPreflight,
+  ) {
+    super();
+  }
+
+  async execute(command: SetWorkflowActivationCommand): Promise<Readonly<{ active: boolean }>> {
+    const workflowId = decodeURIComponent(command.workflowId);
+    if (command.active) {
+      await this.workflowActivationPreflight.assertCanActivate(command.workflowId);
+    }
+    await this.workflowActivationRepository.upsert(workflowId, command.active);
+    this.workflowActivationPolicy.set(workflowId, command.active);
+    await this.engine.syncWorkflowTriggersForActivation(workflowId);
+    return { active: command.active };
+  }
+}

package/src/application/commands/StartWorkflowRunCommand.ts

@@ -0,0 +1,8 @@
+import { Command } from "../bus/Command";
+import type { CreateRunRequest, RunCommandResult } from "../contracts/RunContracts";
+
+export class StartWorkflowRunCommand extends Command<RunCommandResult> {
+  constructor(public readonly body: CreateRunRequest) {
+    super();
+  }
+}

package/src/application/commands/StartWorkflowRunCommandHandler.ts

@@ -0,0 +1,286 @@
+import type {
+  Items,
+  NodeId,
+  PersistedMutableRunState,
+  PersistedRunState,
+  RunCurrentState,
+  RunStopCondition,
+  WorkflowDefinition,
+} from "@codemation/core";
+import { ItemsInputNormalizer, inject } from "@codemation/core";
+import { RunIntentService } from "@codemation/core/bootstrap";
+import { Engine } from "@codemation/core/bootstrap";
+import type { Logger, LoggerFactory } from "../logging/Logger";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import type { WorkflowDebuggerOverlayRepository } from "../../domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDefinitionRepository } from "../../domain/workflows/WorkflowDefinitionRepository";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { ApplicationRequestError } from "../ApplicationRequestError";
+import { CommandHandler } from "../bus/CommandHandler";
+import type { CreateRunRequest, RunCommandResult } from "../contracts/RunContracts";
+import { WorkflowDebuggerOverlayStateFactory } from "../workflows/WorkflowDebuggerOverlayStateFactory";
+import { StartWorkflowRunCommand } from "./StartWorkflowRunCommand";
+
+@HandlesCommand.forCommand(StartWorkflowRunCommand)
+export class StartWorkflowRunCommandHandler extends CommandHandler<StartWorkflowRunCommand, RunCommandResult> {
+  private readonly routesLog: Logger;
+
+  constructor(
+    @inject(Engine)
+    private readonly engine: Engine,
+    @inject(ItemsInputNormalizer)
+    private readonly itemsInputNormalizer: ItemsInputNormalizer,
+    @inject(RunIntentService)
+    private readonly runIntentService: RunIntentService,
+    @inject(ApplicationTokens.WorkflowDefinitionRepository)
+    private readonly workflowDefinitionRepository: WorkflowDefinitionRepository,
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+    @inject(ApplicationTokens.WorkflowDebuggerOverlayRepository)
+    private readonly workflowDebuggerOverlayRepository: WorkflowDebuggerOverlayRepository,
+    @inject(ApplicationTokens.LoggerFactory)
+    loggerFactory: LoggerFactory,
+  ) {
+    super();
+    this.routesLog = loggerFactory.create("codemation-routes.server");
+  }
+
+  async execute(command: StartWorkflowRunCommand): Promise<RunCommandResult> {
+    const body = command.body;
+    if (!body.workflowId) {
+      throw new ApplicationRequestError(400, "Missing workflowId");
+    }
+    const sourceState =
+      body.sourceRunId && !body.currentState ? await this.workflowRunRepository.load(body.sourceRunId) : undefined;
+    const debuggerOverlay = await this.workflowDebuggerOverlayRepository.load(body.workflowId);
+    const workflow = await this.resolveWorkflow(body);
+    if (!workflow) {
+      throw new ApplicationRequestError(404, "Unknown workflowId");
+    }
+    const executionOptions = body.mode
+      ? {
+          mode: body.mode,
+          sourceWorkflowId: body.workflowId,
+          sourceRunId: body.sourceRunId ?? debuggerOverlay?.copiedFromRunId,
+          derivedFromRunId: body.sourceRunId ?? debuggerOverlay?.copiedFromRunId,
+        }
+      : undefined;
+    const legacyStartNodeId = body.startAt as NodeId | undefined;
+    const clearFromNodeId = body.clearFromNodeId as NodeId | undefined;
+    const requestedItems = await this.resolveRequestedItems({
+      workflow,
+      body,
+      clearFromNodeId,
+    });
+    const items = this.resolveRunRequestItems(workflow, legacyStartNodeId, requestedItems);
+    const currentState = this.createCurrentState({
+      workflowId: body.workflowId,
+      requestedCurrentState: body.currentState,
+      sourceState,
+      debuggerOverlay,
+    });
+    const result =
+      legacyStartNodeId && this.hasReusableCurrentState(currentState) && !clearFromNodeId
+        ? await this.runIntentService.rerunFromNode({
+            workflow,
+            nodeId: legacyStartNodeId,
+            currentState,
+            items: requestedItems,
+            executionOptions,
+            workflowSnapshot: sourceState?.workflowSnapshot,
+            mutableState: this.cloneMutableState(currentState.mutableState),
+          })
+        : await this.runIntentService.startWorkflow({
+            workflow,
+            startAt: legacyStartNodeId && !body.sourceRunId && !body.stopAt ? legacyStartNodeId : undefined,
+            items,
+            executionOptions,
+            workflowSnapshot: sourceState?.workflowSnapshot,
+            mutableState: this.cloneMutableState(currentState.mutableState),
+            currentState,
+            reset: this.createResetRequest(clearFromNodeId),
+            stopCondition:
+              legacyStartNodeId && !body.sourceRunId && !body.currentState && !body.stopAt
+                ? undefined
+                : this.createStopCondition(body.stopAt),
+          });
+    const state = (await this.workflowRunRepository.load(result.runId)) ?? null;
+    this.routesLog.info(
+      `postRun workflow=${workflow.id} runId=${result.runId} status=${result.status} persistedStatus=${state?.status ?? "missing"}`,
+    );
+    return {
+      runId: result.runId,
+      workflowId: result.workflowId,
+      startedAt: result.startedAt,
+      status: result.status,
+      state,
+    };
+  }
+
+  private async resolveWorkflow(body: CreateRunRequest): Promise<WorkflowDefinition | undefined> {
+    if (body.currentState) {
+      if (!body.workflowId) {
+        return undefined;
+      }
+      return await this.workflowDefinitionRepository.getDefinition(body.workflowId);
+    }
+    if (body.sourceRunId) {
+      const sourceState = await this.workflowRunRepository.load(body.sourceRunId);
+      if (!sourceState) {
+        return undefined;
+      }
+      return this.engine.resolveWorkflowSnapshot({
+        workflowId: sourceState.workflowId,
+        workflowSnapshot: sourceState.workflowSnapshot,
+      });
+    }
+    if (!body.workflowId) {
+      return undefined;
+    }
+    return await this.workflowDefinitionRepository.getDefinition(body.workflowId);
+  }
+
+  private resolveRunRequestItems(workflow: WorkflowDefinition, startAt: string | undefined, items?: Items): Items {
+    if (items !== undefined) {
+      return items;
+    }
+    return this.isTriggerStart(workflow, startAt) ? [] : [{ json: {} }];
+  }
+
+  private async resolveRequestedItems(
+    args: Readonly<{
+      workflow: WorkflowDefinition;
+      body: CreateRunRequest;
+      clearFromNodeId: NodeId | undefined;
+    }>,
+  ): Promise<Items | undefined> {
+    const triggerNodeId = this.resolveTriggerTestNodeId(args);
+    const normalizedItems = args.body.items == null ? undefined : this.itemsInputNormalizer.normalize(args.body.items);
+    if (!this.shouldSynthesizeTriggerItems(args.body, triggerNodeId, normalizedItems)) {
+      return normalizedItems;
+    }
+    return await this.engine.createTriggerTestItems({
+      workflow: args.workflow,
+      nodeId: triggerNodeId!,
+    });
+  }
+
+  private isTriggerStart(workflow: WorkflowDefinition, startAt: string | undefined): boolean {
+    const resolvedStartAt =
+      startAt ?? workflow.nodes.find((node) => node.kind === "trigger")?.id ?? workflow.nodes[0]?.id;
+    const startNode = resolvedStartAt ? workflow.nodes.find((node) => node.id === resolvedStartAt) : undefined;
+    return startNode?.kind === "trigger";
+  }
+
+  private resolveTriggerTestNodeId(
+    args: Readonly<{
+      workflow: WorkflowDefinition;
+      body: CreateRunRequest;
+      clearFromNodeId: NodeId | undefined;
+    }>,
+  ): NodeId | undefined {
+    const stopAtNodeId = args.body.stopAt as NodeId | undefined;
+    if (stopAtNodeId && this.isTriggerNode(args.workflow, stopAtNodeId)) {
+      return stopAtNodeId;
+    }
+    if (!args.body.sourceRunId && !args.clearFromNodeId && !stopAtNodeId) {
+      if (args.body.currentState && !args.body.synthesizeTriggerItems) {
+        return undefined;
+      }
+      return args.workflow.nodes.find((node) => node.kind === "trigger")?.id;
+    }
+    return undefined;
+  }
+
+  private shouldSynthesizeTriggerItems(
+    body: CreateRunRequest,
+    triggerNodeId: NodeId | undefined,
+    normalizedItems: Items | undefined,
+  ): boolean {
+    if (!triggerNodeId) {
+      return false;
+    }
+    if (body.synthesizeTriggerItems) {
+      return true;
+    }
+    if (normalizedItems && normalizedItems.length > 0) {
+      return false;
+    }
+    return body.stopAt === triggerNodeId;
+  }
+
+  private isTriggerNode(workflow: WorkflowDefinition, nodeId: NodeId): boolean {
+    return workflow.nodes.find((node) => node.id === nodeId)?.kind === "trigger";
+  }
+
+  private cloneMutableState(mutableState: PersistedRunState["mutableState"]): PersistedMutableRunState | undefined {
+    if (!mutableState) {
+      return undefined;
+    }
+    return JSON.parse(JSON.stringify(mutableState)) as PersistedMutableRunState;
+  }
+
+  private cloneRunCurrentState(state: PersistedRunState | undefined): RunCurrentState {
+    if (!state) {
+      return WorkflowDebuggerOverlayStateFactory.cloneCurrentState(undefined);
+    }
+    return {
+      outputsByNode: JSON.parse(JSON.stringify(state.outputsByNode)) as RunCurrentState["outputsByNode"],
+      nodeSnapshotsByNodeId: JSON.parse(
+        JSON.stringify(state.nodeSnapshotsByNodeId),
+      ) as RunCurrentState["nodeSnapshotsByNodeId"],
+      mutableState: this.cloneMutableState(state.mutableState),
+    };
+  }
+
+  private createCurrentState(
+    args: Readonly<{
+      workflowId: string;
+      requestedCurrentState: RunCurrentState | undefined;
+      sourceState: PersistedRunState | undefined;
+      debuggerOverlay: Awaited<ReturnType<WorkflowDebuggerOverlayRepository["load"]>>;
+    }>,
+  ): RunCurrentState {
+    if (args.requestedCurrentState) {
+      return WorkflowDebuggerOverlayStateFactory.cloneCurrentState(args.requestedCurrentState);
+    }
+    const baseCurrentState = args.sourceState
+      ? this.cloneRunCurrentState(args.sourceState)
+      : WorkflowDebuggerOverlayStateFactory.cloneCurrentState(args.debuggerOverlay?.currentState);
+    if (!args.sourceState || !args.debuggerOverlay || args.debuggerOverlay.workflowId !== args.workflowId) {
+      return baseCurrentState;
+    }
+    return {
+      ...baseCurrentState,
+      mutableState: this.cloneMutableState(args.debuggerOverlay.currentState.mutableState),
+    };
+  }
+
+  private createStopCondition(stopAtNodeId: string | undefined): RunStopCondition {
+    if (!stopAtNodeId) {
+      return { kind: "workflowCompleted" };
+    }
+    return {
+      kind: "nodeCompleted",
+      nodeId: stopAtNodeId as NodeId,
+    };
+  }
+
+  private createResetRequest(clearFromNodeId: NodeId | undefined): Readonly<{ clearFromNodeId: NodeId }> | undefined {
+    if (!clearFromNodeId) {
+      return undefined;
+    }
+    return {
+      clearFromNodeId,
+    };
+  }
+
+  private hasReusableCurrentState(currentState: RunCurrentState): boolean {
+    return (
+      Object.keys(currentState.outputsByNode).length > 0 ||
+      Object.keys(currentState.nodeSnapshotsByNodeId).length > 0 ||
+      Object.keys(currentState.mutableState?.nodesById ?? {}).length > 0
+    );
+  }
+}

package/src/application/commands/TestCredentialInstanceCommand.ts

@@ -0,0 +1,9 @@
+import type { CredentialHealth } from "@codemation/core";
+
+import { Command } from "../bus/Command";
+
+export class TestCredentialInstanceCommand extends Command<CredentialHealth> {
+  constructor(public readonly instanceId: string) {
+    super();
+  }
+}

package/src/application/commands/TestCredentialInstanceCommandHandler.ts

@@ -0,0 +1,28 @@
+import type { CredentialHealth } from "@codemation/core";
+
+import { inject } from "@codemation/core";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { TestCredentialInstanceCommand } from "./TestCredentialInstanceCommand";
+
+import { CredentialTestService } from "../../domain/credentials/CredentialServices";
+
+@HandlesCommand.forCommand(TestCredentialInstanceCommand)
+export class TestCredentialInstanceCommandHandler extends CommandHandler<
+  TestCredentialInstanceCommand,
+  CredentialHealth
+> {
+  constructor(
+    @inject(CredentialTestService)
+    private readonly credentialTestService: CredentialTestService,
+  ) {
+    super();
+  }
+
+  async execute(command: TestCredentialInstanceCommand): Promise<CredentialHealth> {
+    return await this.credentialTestService.test(command.instanceId);
+  }
+}

package/src/application/commands/UpdateCredentialInstanceCommand.ts

@@ -0,0 +1,12 @@
+import type { CredentialInstanceDto, UpdateCredentialInstanceRequest } from "../contracts/CredentialContractsRegistry";
+
+import { Command } from "../bus/Command";
+
+export class UpdateCredentialInstanceCommand extends Command<CredentialInstanceDto> {
+  constructor(
+    public readonly instanceId: string,
+    public readonly body: UpdateCredentialInstanceRequest,
+  ) {
+    super();
+  }
+}

package/src/application/commands/UpdateCredentialInstanceCommandHandler.ts

@@ -0,0 +1,28 @@
+import { inject } from "@codemation/core";
+
+import type { CredentialInstanceDto } from "../contracts/CredentialContractsRegistry";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UpdateCredentialInstanceCommand } from "./UpdateCredentialInstanceCommand";
+
+import { CredentialInstanceService } from "../../domain/credentials/CredentialServices";
+
+@HandlesCommand.forCommand(UpdateCredentialInstanceCommand)
+export class UpdateCredentialInstanceCommandHandler extends CommandHandler<
+  UpdateCredentialInstanceCommand,
+  CredentialInstanceDto
+> {
+  constructor(
+    @inject(CredentialInstanceService)
+    private readonly credentialInstanceService: CredentialInstanceService,
+  ) {
+    super();
+  }
+
+  async execute(command: UpdateCredentialInstanceCommand): Promise<CredentialInstanceDto> {
+    return await this.credentialInstanceService.update(command.instanceId, command.body);
+  }
+}

package/src/application/commands/UpdateUserAccountStatusCommand.ts

@@ -0,0 +1,12 @@
+import type { UserAccountDto, UserAccountStatus } from "../contracts/userDirectoryContracts.types";
+
+import { Command } from "../bus/Command";
+
+export class UpdateUserAccountStatusCommand extends Command<UserAccountDto> {
+  constructor(
+    public readonly userId: string,
+    public readonly status: UserAccountStatus,
+  ) {
+    super();
+  }
+}

package/src/application/commands/UpdateUserAccountStatusCommandHandler.ts

@@ -0,0 +1,24 @@
+import { inject } from "@codemation/core";
+
+import type { UserAccountDto } from "../contracts/userDirectoryContracts.types";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UserAccountService } from "../../domain/users/UserAccountServiceRegistry";
+import { UpdateUserAccountStatusCommand } from "./UpdateUserAccountStatusCommand";
+
+@HandlesCommand.forCommand(UpdateUserAccountStatusCommand)
+export class UpdateUserAccountStatusCommandHandler extends CommandHandler<
+  UpdateUserAccountStatusCommand,
+  UserAccountDto
+> {
+  constructor(@inject(UserAccountService) private readonly userAccounts: UserAccountService) {
+    super();
+  }
+
+  async execute(command: UpdateUserAccountStatusCommand): Promise<UserAccountDto> {
+    return await this.userAccounts.updateAccountStatus(command.userId, command.status);
+  }
+}

package/src/application/commands/UploadOverlayPinnedBinaryCommand.ts

@@ -0,0 +1,16 @@
+import type { BinaryAttachment, BinaryBody } from "@codemation/core";
+import { Command } from "../bus/Command";
+
+export class UploadOverlayPinnedBinaryCommand extends Command<BinaryAttachment> {
+  constructor(
+    public readonly workflowId: string,
+    public readonly nodeId: string,
+    public readonly itemIndex: number,
+    public readonly attachmentName: string,
+    public readonly mimeType: string,
+    public readonly body: BinaryBody,
+    public readonly filename?: string,
+  ) {
+    super();
+  }
+}

package/src/application/commands/UploadOverlayPinnedBinaryCommandHandler.ts

@@ -0,0 +1,31 @@
+import { inject } from "@codemation/core";
+import type { BinaryAttachment } from "@codemation/core";
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+import { OverlayPinnedBinaryUploadService } from "../binary/OverlayPinnedBinaryUploadService";
+import { CommandHandler } from "../bus/CommandHandler";
+import { UploadOverlayPinnedBinaryCommand } from "./UploadOverlayPinnedBinaryCommand";
+
+@HandlesCommand.forCommand(UploadOverlayPinnedBinaryCommand)
+export class UploadOverlayPinnedBinaryCommandHandler extends CommandHandler<
+  UploadOverlayPinnedBinaryCommand,
+  BinaryAttachment
+> {
+  constructor(
+    @inject(OverlayPinnedBinaryUploadService)
+    private readonly overlayPinnedBinaryUpload: OverlayPinnedBinaryUploadService,
+  ) {
+    super();
+  }
+
+  async execute(command: UploadOverlayPinnedBinaryCommand): Promise<BinaryAttachment> {
+    return this.overlayPinnedBinaryUpload.attach({
+      workflowId: command.workflowId,
+      nodeId: command.nodeId,
+      itemIndex: command.itemIndex,
+      name: command.attachmentName,
+      mimeType: command.mimeType,
+      body: command.body,
+      filename: command.filename,
+    });
+  }
+}

package/src/application/commands/UpsertCredentialBindingCommand.ts

@@ -0,0 +1,11 @@
+import type { CredentialBinding } from "@codemation/core";
+
+import type { UpsertCredentialBindingRequest } from "../contracts/CredentialContractsRegistry";
+
+import { Command } from "../bus/Command";
+
+export class UpsertCredentialBindingCommand extends Command<CredentialBinding> {
+  constructor(public readonly body: UpsertCredentialBindingRequest) {
+    super();
+  }
+}

package/src/application/commands/UpsertCredentialBindingCommandHandler.ts

@@ -0,0 +1,28 @@
+import type { CredentialBinding } from "@codemation/core";
+
+import { inject } from "@codemation/core";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UpsertCredentialBindingCommand } from "./UpsertCredentialBindingCommand";
+
+import { CredentialBindingService } from "../../domain/credentials/CredentialServices";
+
+@HandlesCommand.forCommand(UpsertCredentialBindingCommand)
+export class UpsertCredentialBindingCommandHandler extends CommandHandler<
+  UpsertCredentialBindingCommand,
+  CredentialBinding
+> {
+  constructor(
+    @inject(CredentialBindingService)
+    private readonly credentialBindingService: CredentialBindingService,
+  ) {
+    super();
+  }
+
+  async execute(command: UpsertCredentialBindingCommand): Promise<CredentialBinding> {
+    return await this.credentialBindingService.upsertBinding(command.body);
+  }
+}

package/src/application/commands/UpsertLocalBootstrapUserCommand.ts

@@ -0,0 +1,12 @@
+import type { UpsertLocalBootstrapUserResultDto } from "../contracts/userDirectoryContracts.types";
+
+import { Command } from "../bus/Command";
+
+export class UpsertLocalBootstrapUserCommand extends Command<UpsertLocalBootstrapUserResultDto> {
+  constructor(
+    public readonly email: string,
+    public readonly password: string,
+  ) {
+    super();
+  }
+}

package/src/application/commands/UpsertLocalBootstrapUserCommandHandler.ts

@@ -0,0 +1,24 @@
+import { inject } from "@codemation/core";
+
+import type { UpsertLocalBootstrapUserResultDto } from "../contracts/userDirectoryContracts.types";
+
+import { CommandHandler } from "../bus/CommandHandler";
+
+import { HandlesCommand } from "../../infrastructure/di/HandlesCommandRegistry";
+
+import { UserAccountService } from "../../domain/users/UserAccountServiceRegistry";
+import { UpsertLocalBootstrapUserCommand } from "./UpsertLocalBootstrapUserCommand";
+
+@HandlesCommand.forCommand(UpsertLocalBootstrapUserCommand)
+export class UpsertLocalBootstrapUserCommandHandler extends CommandHandler<
+  UpsertLocalBootstrapUserCommand,
+  UpsertLocalBootstrapUserResultDto
+> {
+  constructor(@inject(UserAccountService) private readonly userAccounts: UserAccountService) {
+    super();
+  }
+
+  async execute(command: UpsertLocalBootstrapUserCommand): Promise<UpsertLocalBootstrapUserResultDto> {
+    return await this.userAccounts.upsertBootstrapLocalUser(command.email, command.password);
+  }
+}

package/src/application/commands/UserAccountCommandHandlers.ts

@@ -0,0 +1,10 @@
+export { AcceptUserInviteCommand } from "./AcceptUserInviteCommand";
+export { AcceptUserInviteCommandHandler } from "./AcceptUserInviteCommandHandler";
+export { InviteUserCommand } from "./InviteUserCommand";
+export { InviteUserCommandHandler } from "./InviteUserCommandHandler";
+export { RegenerateUserInviteCommand } from "./RegenerateUserInviteCommand";
+export { RegenerateUserInviteCommandHandler } from "./RegenerateUserInviteCommandHandler";
+export { UpdateUserAccountStatusCommand } from "./UpdateUserAccountStatusCommand";
+export { UpdateUserAccountStatusCommandHandler } from "./UpdateUserAccountStatusCommandHandler";
+export { UpsertLocalBootstrapUserCommand } from "./UpsertLocalBootstrapUserCommand";
+export { UpsertLocalBootstrapUserCommandHandler } from "./UpsertLocalBootstrapUserCommandHandler";