@codemation/host 0.0.1

package/src/domain/workflows/WorkflowActivationPreflightRules.ts

@@ -0,0 +1,77 @@
+import type { WorkflowCredentialHealthDto } from "../../application/contracts/CredentialContractsRegistry";
+import { getPersistedRuntimeTypeMetadata, injectable, type WorkflowDefinition } from "@codemation/core";
+import { MissingRuntimeTriggerToken } from "@codemation/core/bootstrap";
+import { ManualTriggerNode } from "@codemation/core-nodes";
+
+@injectable()
+export class WorkflowActivationPreflightRules {
+  private readonly manualTriggerTypeName: string;
+  private readonly missingRuntimeTriggerTypeName: string;
+
+  constructor() {
+    this.manualTriggerTypeName = this.resolveRuntimeTypeTokenName(ManualTriggerNode);
+    this.missingRuntimeTriggerTypeName = this.resolveRuntimeTypeTokenName(MissingRuntimeTriggerToken);
+  }
+
+  /**
+   * Compare node runtime tokens by persisted decorator name (and constructor name fallback).
+   * Reference equality breaks when the host and consumer workflow each load a separate copy of
+   * `@codemation/core-nodes` (duplicate class identity for the same logical trigger type).
+   */
+  private resolveRuntimeTypeTokenName(token: unknown): string {
+    const meta = getPersistedRuntimeTypeMetadata(token);
+    if (meta) {
+      return meta.persistedName;
+    }
+    if (typeof token === "function") {
+      return (token as { name?: string }).name ?? "";
+    }
+    return "";
+  }
+
+  private isManualTriggerType(token: unknown): boolean {
+    return this.resolveRuntimeTypeTokenName(token) === this.manualTriggerTypeName;
+  }
+
+  private isMissingRuntimeTriggerType(token: unknown): boolean {
+    return this.resolveRuntimeTypeTokenName(token) === this.missingRuntimeTriggerTypeName;
+  }
+
+  collectNonManualTriggerErrors(workflow: WorkflowDefinition): ReadonlyArray<string> {
+    const triggerNodes = workflow.nodes.filter((n) => n.kind === "trigger");
+    const hasActivatable = triggerNodes.some(
+      (n) => !this.isManualTriggerType(n.type) && !this.isMissingRuntimeTriggerType(n.type),
+    );
+    if (hasActivatable) {
+      return [];
+    }
+    if (triggerNodes.length === 0) {
+      return ["This workflow has no trigger node. Add a non-manual trigger (for example a webhook) before activating."];
+    }
+    const onlyManual = triggerNodes.every((n) => this.isManualTriggerType(n.type));
+    if (onlyManual) {
+      return [
+        "This workflow only has a manual run trigger. Add a non-manual trigger (for example a webhook) before activating.",
+      ];
+    }
+    return [
+      "This workflow has no usable automatic trigger (the configured trigger may be missing or invalid). Fix the trigger before activating.",
+    ];
+  }
+
+  collectRequiredCredentialErrors(health: WorkflowCredentialHealthDto): ReadonlyArray<string> {
+    const lines: string[] = [];
+    for (const slot of health.slots) {
+      if (slot.requirement.optional) {
+        continue;
+      }
+      if (slot.health.status === "unbound") {
+        const nodeLabel = slot.nodeName ?? slot.nodeId;
+        lines.push(
+          `Required credential "${slot.requirement.label}" (${slot.requirement.slotKey}) on "${nodeLabel}" is not bound.`,
+        );
+      }
+    }
+    return lines;
+  }
+}

package/src/domain/workflows/WorkflowActivationRepository.ts

@@ -0,0 +1,9 @@
+export type WorkflowActivationRow = Readonly<{
+  workflowId: string;
+  isActive: boolean;
+}>;
+
+export interface WorkflowActivationRepository {
+  loadAll(): Promise<ReadonlyArray<WorkflowActivationRow>>;
+  upsert(workflowId: string, active: boolean): Promise<void>;
+}

package/src/domain/workflows/WorkflowDebuggerOverlayRepository.ts

@@ -0,0 +1,7 @@
+import type { WorkflowDebuggerOverlayState } from "./WorkflowDebuggerOverlayState";
+
+export interface WorkflowDebuggerOverlayRepository {
+  load(workflowId: string): Promise<WorkflowDebuggerOverlayState | undefined>;
+
+  save(state: WorkflowDebuggerOverlayState): Promise<void>;
+}

package/src/domain/workflows/WorkflowDebuggerOverlayState.ts

@@ -0,0 +1,8 @@
+import type { RunCurrentState } from "@codemation/core";
+
+export type WorkflowDebuggerOverlayState = Readonly<{
+  workflowId: string;
+  updatedAt: string;
+  copiedFromRunId?: string;
+  currentState: RunCurrentState;
+}>;

package/src/domain/workflows/WorkflowDefinitionRepository.ts

@@ -0,0 +1,11 @@
+import type { WorkflowDefinition } from "@codemation/core";
+
+export interface WorkflowDefinitionRepository {
+  listDefinitions(): Promise<ReadonlyArray<WorkflowDefinition>>;
+
+  getDefinition(workflowId: string): Promise<WorkflowDefinition | undefined>;
+
+  resolveSnapshot(
+    args: Readonly<{ workflowId: string; workflowSnapshot?: unknown }>,
+  ): Promise<WorkflowDefinition | undefined>;
+}

package/src/index.ts

@@ -0,0 +1,58 @@
+export type { CommandBus } from "./application/bus/CommandBus";
+export type { QueryBus } from "./application/bus/QueryBus";
+export { ListUserAccountsQuery } from "./application/queries/ListUserAccountsQuery";
+export { UpsertLocalBootstrapUserCommand } from "./application/commands/UpsertLocalBootstrapUserCommand";
+export type { UpsertLocalBootstrapUserResultDto } from "./application/contracts/userDirectoryContracts.types";
+export { CodemationApplication } from "./codemationApplication";
+export type { CodemationApplicationConfig, CodemationStopHandle } from "./codemationApplication";
+export { ApplicationTokens } from "./applicationTokens";
+export { CodemationBootstrapRequest } from "./bootstrap/CodemationBootstrapRequest";
+export { CodemationFrontendBootstrapRequest } from "./bootstrap/CodemationFrontendBootstrapRequest";
+export { CodemationWorkerBootstrapRequest } from "./bootstrap/CodemationWorkerBootstrapRequest";
+export type { CodemationWhitelabelConfig } from "./presentation/config/CodemationWhitelabelConfig";
+export type { AppConfig } from "./presentation/config/AppConfig";
+export type { CodemationApplicationFacade } from "./presentation/config/CodemationApplicationFacade";
+export type {
+  CodemationAuthConfig,
+  CodemationAuthKind,
+  CodemationAuthOAuthProviderConfig,
+  CodemationAuthOidcProviderConfig,
+} from "./presentation/config/CodemationAuthConfig";
+export type { CodemationClassToken } from "./presentation/config/CodemationClassToken";
+export type {
+  CodemationAppDefinition,
+  CodemationAppSchedulerConfig,
+  CodemationAppSchedulerKind,
+  CodemationApplicationRuntimeConfig,
+  CodemationConfig,
+  CodemationDatabaseConfig,
+  CodemationDatabaseKind,
+  CodemationEngineExecutionLimitsConfig,
+  CodemationEventBusConfig,
+  CodemationEventBusKind,
+  CodemationSchedulerConfig,
+  CodemationSchedulerKind,
+} from "./presentation/config/CodemationConfig";
+export type {
+  CodemationAppContext,
+  CodemationRegistrationContextBase,
+} from "./presentation/config/CodemationAppContext";
+export type {
+  CodemationLogConfig,
+  CodemationLogLevelName,
+  CodemationLogRule,
+} from "./presentation/config/CodemationLogConfig";
+export type {
+  CodemationPackageManifest,
+  CodemationPluginPackageManifest,
+} from "./presentation/config/CodemationPackageManifest";
+export type { CodemationPlugin, CodemationPluginContext } from "./presentation/config/CodemationPlugin";
+export { CodemationPluginListMerger } from "./presentation/config/CodemationPluginListMerger";
+export type { CodemationWorkflowDiscovery } from "./presentation/config/CodemationWorkflowDiscovery";
+export {
+  ApiPaths,
+  CodemationConsumerConfigLoader,
+  CodemationPostgresPrismaClientFactory,
+  CodemationServerGateway,
+  PrismaClient,
+} from "./server";

package/src/infrastructure/auth/AuthJsSessionVerifier.ts

@@ -0,0 +1,26 @@
+import { getToken } from "@auth/core/jwt";
+import type { AuthenticatedPrincipal } from "../../application/auth/AuthenticatedPrincipal";
+import type { SessionVerifier } from "../../application/auth/SessionVerifier";
+
+export class AuthJsSessionVerifier implements SessionVerifier {
+  constructor(private readonly authSecret: string) {}
+
+  async verify(request: Request): Promise<AuthenticatedPrincipal | null> {
+    const requestUrl = new URL(request.url);
+    const secureCookie = requestUrl.protocol === "https:";
+    const token = await getToken({
+      req: request,
+      secret: this.authSecret,
+      secureCookie,
+      salt: "authjs.session-token",
+    });
+    if (!token?.sub || typeof token.sub !== "string") {
+      return null;
+    }
+    return {
+      id: token.sub,
+      email: typeof token.email === "string" ? token.email : null,
+      name: typeof token.name === "string" ? token.name : null,
+    };
+  }
+}

package/src/infrastructure/auth/DevelopmentSessionBypassVerifier.ts

@@ -0,0 +1,12 @@
+import type { AuthenticatedPrincipal } from "../../application/auth/AuthenticatedPrincipal";
+import type { SessionVerifier } from "../../application/auth/SessionVerifier";
+
+export class DevelopmentSessionBypassVerifier implements SessionVerifier {
+  async verify(): Promise<AuthenticatedPrincipal | null> {
+    return {
+      id: "codemation-development-bypass",
+      email: "development@codemation.local",
+      name: "Development bypass user",
+    };
+  }
+}

package/src/infrastructure/binary/BinaryBodyNodeReadableFactory.ts

@@ -0,0 +1,22 @@
+import { Readable } from "node:stream";
+
+import { ReadableStream } from "node:stream/web";
+
+import type { BinaryBody } from "@codemation/core";
+
+export class BinaryBodyNodeReadableFactory {
+  constructor(private readonly body: BinaryBody) {}
+
+  create(): Readable {
+    if (this.body instanceof Uint8Array) {
+      return Readable.from([this.body]);
+    }
+    if (this.body instanceof ArrayBuffer) {
+      return Readable.from([new Uint8Array(this.body)]);
+    }
+    if (this.body instanceof ReadableStream) {
+      return Readable.fromWeb(this.body);
+    }
+    return Readable.from(this.body);
+  }
+}

package/src/infrastructure/binary/CountingSha256Transform.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+
+import { Transform } from "node:stream";
+
+export class CountingSha256Transform extends Transform {
+  private readonly hash = createHash("sha256");
+  private byteCount = 0;
+
+  get size(): number {
+    return this.byteCount;
+  }
+
+  get sha256(): string {
+    return this.hash.digest("hex");
+  }
+
+  override _transform(
+    chunk: Buffer,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null, data?: Buffer) => void,
+  ): void {
+    this.byteCount += chunk.byteLength;
+    this.hash.update(chunk);
+    callback(null, chunk);
+  }
+}

package/src/infrastructure/binary/LocalFilesystemBinaryStorageRegistry.ts

@@ -0,0 +1,86 @@
+import { createReadStream, createWriteStream } from "node:fs";
+
+import { mkdir, rm, stat } from "node:fs/promises";
+
+import path from "node:path";
+
+import { Readable } from "node:stream";
+
+import { ReadableStream } from "node:stream/web";
+
+import { pipeline } from "node:stream/promises";
+
+import type {
+  BinaryBody,
+  BinaryStorage,
+  BinaryStorageReadResult,
+  BinaryStorageStatResult,
+  BinaryStorageWriteResult,
+} from "@codemation/core";
+
+import { BinaryBodyNodeReadableFactory } from "./BinaryBodyNodeReadableFactory";
+import { CountingSha256Transform } from "./CountingSha256Transform";
+
+export class LocalFilesystemBinaryStorage implements BinaryStorage {
+  readonly driverName = "filesystem";
+
+  constructor(private readonly baseDirectory: string) {}
+
+  async write(args: { storageKey: string; body: BinaryBody }): Promise<BinaryStorageWriteResult> {
+    const targetPath = this.resolveAbsolutePath(args.storageKey);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    const readable = new BinaryBodyNodeReadableFactory(args.body).create();
+    const countingTransform = new CountingSha256Transform();
+    const writable = createWriteStream(targetPath);
+    await pipeline(readable, countingTransform, writable);
+    return {
+      storageKey: args.storageKey,
+      size: countingTransform.size,
+      sha256: countingTransform.sha256,
+    };
+  }
+
+  async openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined> {
+    const targetPath = this.resolveAbsolutePath(storageKey);
+    try {
+      const fileStat = await stat(targetPath);
+      return {
+        body: Readable.toWeb(createReadStream(targetPath)) as ReadableStream<Uint8Array>,
+        size: fileStat.size,
+      };
+    } catch {
+      return undefined;
+    }
+  }
+
+  async stat(storageKey: string): Promise<BinaryStorageStatResult> {
+    const targetPath = this.resolveAbsolutePath(storageKey);
+    try {
+      const fileStat = await stat(targetPath);
+      return {
+        exists: true,
+        size: fileStat.size,
+      };
+    } catch {
+      return {
+        exists: false,
+      };
+    }
+  }
+
+  async delete(storageKey: string): Promise<void> {
+    await rm(this.resolveAbsolutePath(storageKey), { force: true });
+  }
+
+  private resolveAbsolutePath(storageKey: string): string {
+    const absoluteBaseDirectory = path.resolve(this.baseDirectory);
+    const targetPath = path.resolve(absoluteBaseDirectory, storageKey);
+    if (!targetPath.startsWith(`${absoluteBaseDirectory}${path.sep}`) && targetPath !== absoluteBaseDirectory) {
+      throw new Error(`Refused to access binary storage path outside base directory: ${storageKey}`);
+    }
+    return targetPath;
+  }
+}
+
+export { BinaryBodyNodeReadableFactory } from "./BinaryBodyNodeReadableFactory";
+export { CountingSha256Transform } from "./CountingSha256Transform";

package/src/infrastructure/config/CodemationPluginRegistrar.ts

@@ -0,0 +1,44 @@
+import type { Container } from "@codemation/core";
+import type { LoggerFactory } from "../../application/logging/Logger";
+import type { AppConfig } from "../../presentation/config/AppConfig";
+import type { CodemationPlugin } from "../../presentation/config/CodemationPlugin";
+import type { AnyCredentialType } from "@codemation/core";
+
+export class CodemationPluginRegistrar {
+  async apply(
+    args: Readonly<{
+      plugins: ReadonlyArray<CodemationPlugin>;
+      container: Container;
+      appConfig: AppConfig;
+      registerCredentialType: (type: AnyCredentialType) => void;
+      loggerFactory: LoggerFactory;
+    }>,
+  ): Promise<void> {
+    for (const plugin of args.plugins) {
+      await plugin.register({
+        container: args.container,
+        appConfig: args.appConfig,
+        loggerFactory: args.loggerFactory,
+        registerCredentialType: (type) => args.registerCredentialType(type),
+        registerNode: (token, implementation) => {
+          args.container.register(token, {
+            useClass: (implementation ?? token) as never,
+          });
+        },
+        registerValue: (token, value) => {
+          args.container.registerInstance(token, value);
+        },
+        registerClass: (token, implementation) => {
+          args.container.register(token, {
+            useClass: implementation as never,
+          });
+        },
+        registerFactory: (token, factory) => {
+          args.container.register(token, {
+            useFactory: (dependencyContainer) => factory(dependencyContainer),
+          });
+        },
+      });
+    }
+  }
+}

package/src/infrastructure/credentials/FrameworkBuiltinCredentialTypesRegistrar.ts

@@ -0,0 +1,21 @@
+import type { CodemationApplication } from "../../codemationApplication";
+import type { CodemationConfig } from "../../presentation/config/CodemationConfig";
+
+import type { OpenAiApiKeyCredentialTypeFactory } from "./OpenAiApiKeyCredentialTypeFactory";
+
+/**
+ * Registers framework-owned credential types that ship with the host (OpenAI-compatible API keys, etc.).
+ */
+export class FrameworkBuiltinCredentialTypesRegistrar {
+  constructor(private readonly openAiApiKeyCredentialTypeFactory: OpenAiApiKeyCredentialTypeFactory) {}
+
+  register(application: CodemationApplication, config?: CodemationConfig): void {
+    const openAiCredentialType = this.openAiApiKeyCredentialTypeFactory.createCredentialType();
+    const openAiProvidedInConsumerConfig =
+      config?.credentialTypes?.some((entry) => entry.definition.typeId === openAiCredentialType.definition.typeId) ??
+      false;
+    if (!openAiProvidedInConsumerConfig) {
+      application.registerCredentialType(openAiCredentialType);
+    }
+  }
+}

package/src/infrastructure/credentials/OpenAiApiKeyCredentialHealthTester.ts

@@ -0,0 +1,89 @@
+import type { CredentialHealth, CredentialSessionFactoryArgs } from "@codemation/core";
+
+import type { OpenAiApiKeyMaterial, OpenAiApiKeyPublicConfig } from "./OpenAiApiKeyCredentialShapes.types";
+
+/**
+ * Verifies an OpenAI-compatible API key by calling the provider's models list endpoint
+ * (GET `/v1/models` relative to the configured base URL).
+ */
+export class OpenAiApiKeyCredentialHealthTester {
+  constructor(private readonly fetchImpl: typeof globalThis.fetch) {}
+
+  async test(
+    args: CredentialSessionFactoryArgs<OpenAiApiKeyPublicConfig, OpenAiApiKeyMaterial>,
+  ): Promise<CredentialHealth> {
+    const testedAt = new Date().toISOString();
+    const apiKey = String(args.material.apiKey ?? "").trim();
+    if (apiKey.length === 0) {
+      return {
+        status: "failing",
+        message: "OpenAI API key is empty.",
+        testedAt,
+      };
+    }
+
+    const modelsUrl = this.resolveModelsListUrl(args.publicConfig.baseUrl);
+
+    try {
+      const response = await this.fetchImpl(modelsUrl, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+        signal: AbortSignal.timeout(25_000),
+      });
+
+      if (response.ok) {
+        return {
+          status: "healthy",
+          message: "API key verified against the models endpoint.",
+          testedAt,
+        };
+      }
+
+      const message = await this.parseErrorMessage(response);
+      return {
+        status: "failing",
+        message,
+        testedAt,
+      };
+    } catch (error) {
+      return {
+        status: "failing",
+        message: error instanceof Error ? error.message : String(error),
+        testedAt,
+      };
+    }
+  }
+
+  private resolveModelsListUrl(baseUrlRaw: unknown): string {
+    const defaultBase = "https://api.openai.com/v1";
+    const raw = typeof baseUrlRaw === "string" ? baseUrlRaw.trim() : "";
+    const base = raw === "" ? defaultBase : raw.replace(/\/+$/, "");
+    if (base.endsWith("/models")) {
+      return base;
+    }
+    if (base.endsWith("/v1")) {
+      return `${base}/models`;
+    }
+    return `${base}/v1/models`;
+  }
+
+  private async parseErrorMessage(response: Response): Promise<string> {
+    const prefix = `HTTP ${response.status}`;
+    try {
+      const text = await response.text();
+      if (text.trim() === "") {
+        return prefix;
+      }
+      const parsed = JSON.parse(text) as { error?: { message?: string } };
+      const fromApi = parsed.error?.message;
+      if (typeof fromApi === "string" && fromApi.trim() !== "") {
+        return `${prefix}: ${fromApi.trim()}`;
+      }
+      return `${prefix}: ${text.length > 280 ? `${text.slice(0, 280)}…` : text}`;
+    } catch {
+      return prefix;
+    }
+  }
+}

package/src/infrastructure/credentials/OpenAiApiKeyCredentialShapes.types.ts

@@ -0,0 +1,15 @@
+/**
+ * Typed shapes for the `openai.apiKey` credential (public fields, secret material, session object).
+ */
+export type OpenAiApiKeyPublicConfig = Readonly<{
+  baseUrl?: string;
+}>;
+
+export type OpenAiApiKeyMaterial = Readonly<{
+  apiKey?: string;
+}>;
+
+export type OpenAiApiKeySession = Readonly<{
+  apiKey: string;
+  baseUrl?: string;
+}>;

package/src/infrastructure/credentials/OpenAiApiKeyCredentialTypeFactory.ts

@@ -0,0 +1,47 @@
+import type { CredentialType } from "../../domain/credentials/CredentialServices";
+
+import type { OpenAiApiKeyCredentialHealthTester } from "./OpenAiApiKeyCredentialHealthTester";
+import type {
+  OpenAiApiKeyMaterial,
+  OpenAiApiKeyPublicConfig,
+  OpenAiApiKeySession,
+} from "./OpenAiApiKeyCredentialShapes.types";
+
+/**
+ * Builds the OpenAI-compatible API key credential (`openai.apiKey`) registration.
+ * Used by {@link FrameworkBuiltinCredentialTypesRegistrar} and may be listed in {@link CodemationConfig.credentialTypes}
+ * so consumer apps always register the type even when bootstrap order differs.
+ */
+export class OpenAiApiKeyCredentialTypeFactory {
+  constructor(private readonly healthTester: OpenAiApiKeyCredentialHealthTester) {}
+
+  createCredentialType(): CredentialType<OpenAiApiKeyPublicConfig, OpenAiApiKeyMaterial, OpenAiApiKeySession> {
+    return {
+      definition: {
+        typeId: "openai.apiKey",
+        displayName: "OpenAI API key",
+        description: "API key and optional base URL for OpenAI or OpenAI-compatible chat endpoints.",
+        publicFields: [
+          {
+            key: "baseUrl",
+            label: "Base URL",
+            type: "string",
+            placeholder: "https://api.openai.com/v1",
+            helpText: "Leave empty to use the default OpenAI API endpoint.",
+          },
+        ],
+        secretFields: [{ key: "apiKey", label: "API key", type: "password", required: true }],
+        supportedSourceKinds: ["db", "env", "code"],
+      },
+      createSession: async (args) => {
+        const baseUrlRaw = args.publicConfig.baseUrl;
+        const baseUrl = typeof baseUrlRaw === "string" && baseUrlRaw.trim() !== "" ? baseUrlRaw.trim() : undefined;
+        return {
+          apiKey: String(args.material.apiKey ?? ""),
+          baseUrl,
+        };
+      },
+      test: async (args) => this.healthTester.test(args),
+    };
+  }
+}

package/src/infrastructure/di/HandlesCommandRegistry.ts

@@ -0,0 +1,24 @@
+import { injectable, registry } from "@codemation/core";
+import type { Command } from "../../application/bus/Command";
+import type { CommandHandler } from "../../application/bus/CommandHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+
+type AbstractType<TInstance> = abstract new (...args: any[]) => TInstance;
+type ConcreteType<TInstance> = new (...args: any[]) => TInstance;
+
+export const commandHandlerMetadataKey = Symbol.for("codemation.infrastructure.di.CommandHandler");
+
+export class HandlesCommand {
+  static forCommand<TCommand extends Command<TResult>, TResult>(commandType: AbstractType<TCommand>): ClassDecorator {
+    return (target) => {
+      Reflect.defineMetadata(commandHandlerMetadataKey, commandType, target);
+      injectable()(target as never);
+      registry([
+        {
+          token: ApplicationTokens.CommandHandler,
+          useClass: target as unknown as ConcreteType<CommandHandler<Command<unknown>, unknown>>,
+        },
+      ])(target as never);
+    };
+  }
+}

package/src/infrastructure/di/HandlesDomainEventRegistry.ts

@@ -0,0 +1,24 @@
+import { injectable, registry } from "@codemation/core";
+import type { DomainEvent } from "../../application/bus/DomainEvent";
+import type { DomainEventHandler } from "../../application/bus/DomainEventHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+
+type AbstractType<TInstance> = abstract new (...args: any[]) => TInstance;
+type ConcreteType<TInstance> = new (...args: any[]) => TInstance;
+
+export const domainEventHandlerMetadataKey = Symbol.for("codemation.infrastructure.di.DomainEventHandler");
+
+export class HandlesDomainEvent {
+  static for<TEvent extends DomainEvent>(eventType: AbstractType<TEvent>): ClassDecorator {
+    return (target) => {
+      Reflect.defineMetadata(domainEventHandlerMetadataKey, eventType, target);
+      injectable()(target as never);
+      registry([
+        {
+          token: ApplicationTokens.DomainEventHandler,
+          useClass: target as unknown as ConcreteType<DomainEventHandler<DomainEvent>>,
+        },
+      ])(target as never);
+    };
+  }
+}

package/src/infrastructure/di/HandlesQueryRegistry.ts

@@ -0,0 +1,24 @@
+import { injectable, registry } from "@codemation/core";
+import type { Query } from "../../application/bus/Query";
+import type { QueryHandler } from "../../application/bus/QueryHandler";
+import { ApplicationTokens } from "../../applicationTokens";
+
+type AbstractType<TInstance> = abstract new (...args: any[]) => TInstance;
+type ConcreteType<TInstance> = new (...args: any[]) => TInstance;
+
+export const queryHandlerMetadataKey = Symbol.for("codemation.infrastructure.di.QueryHandler");
+
+export class HandlesQuery {
+  static for<TQuery extends Query<TResult>, TResult>(queryType: AbstractType<TQuery>): ClassDecorator {
+    return (target) => {
+      Reflect.defineMetadata(queryHandlerMetadataKey, queryType, target);
+      injectable()(target as never);
+      registry([
+        {
+          token: ApplicationTokens.QueryHandler,
+          useClass: target as unknown as ConcreteType<QueryHandler<Query<unknown>, unknown>>,
+        },
+      ])(target as never);
+    };
+  }
+}