@codemation/host 0.3.0 → 1.0.0

package/src/bootstrap/AppContainerFactory.ts

@@ -365,7 +365,7 @@ export class AppContainerFactory {
         dependencyContainer.resolve(CredentialTypeRegistryImpl),
       ),
     });
-    container.register(CodemationIdFactory, { useClass: CodemationIdFactory });
+    container.registerSingleton(CodemationIdFactory, CodemationIdFactory);
     container.register(CoreTokens.RunIdFactory, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)),
     });
@@ -420,7 +420,7 @@ export class AppContainerFactory {
       },
     });
     container.registerInstance(LogLevelPolicyFactory, logLevelPolicyFactory);
-    container.register(ServerLoggerFactory, { useClass: ServerLoggerFactory });
+    container.registerSingleton(ServerLoggerFactory, ServerLoggerFactory);
     container.register(ApplicationTokens.LoggerFactory, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(ServerLoggerFactory)),
     });
@@ -441,43 +441,41 @@ export class AppContainerFactory {
         );
       }),
     });
-    container.register(PrismaClientFactory, { useClass: PrismaClientFactory });
-    container.register(WorkflowPolicyUiPresentationFactory, { useClass: WorkflowPolicyUiPresentationFactory });
-    container.register(WorkflowDefinitionMapper, { useClass: WorkflowDefinitionMapper });
-    container.register(RequestToWebhookItemMapper, { useClass: RequestToWebhookItemMapper });
-    container.register(WebhookEndpointPathValidator, { useClass: WebhookEndpointPathValidator });
-    container.register(CredentialSecretCipher, { useClass: CredentialSecretCipher });
-    container.register(CredentialMaterialResolver, { useClass: CredentialMaterialResolver });
-    container.register(CredentialFieldEnvOverlayService, { useClass: CredentialFieldEnvOverlayService });
-    container.register(CredentialRuntimeMaterialService, { useClass: CredentialRuntimeMaterialService });
-    container.register(WorkflowCredentialNodeResolver, { useClass: WorkflowCredentialNodeResolver });
-    container.register(CredentialInstanceService, { useClass: CredentialInstanceService });
-    container.register(CredentialBindingService, { useClass: CredentialBindingService });
-    container.register(WorkflowActivationPreflightRules, { useClass: WorkflowActivationPreflightRules });
-    container.register(WorkflowActivationPreflight, { useClass: WorkflowActivationPreflight });
-    container.register(CredentialTestService, { useClass: CredentialTestService });
-    container.register(CredentialSessionServiceImpl, { useClass: CredentialSessionServiceImpl });
+    container.registerSingleton(PrismaClientFactory, PrismaClientFactory);
+    container.registerSingleton(WorkflowPolicyUiPresentationFactory, WorkflowPolicyUiPresentationFactory);
+    container.registerSingleton(WorkflowDefinitionMapper, WorkflowDefinitionMapper);
+    container.registerSingleton(RequestToWebhookItemMapper, RequestToWebhookItemMapper);
+    container.registerSingleton(WebhookEndpointPathValidator, WebhookEndpointPathValidator);
+    container.registerSingleton(CredentialSecretCipher, CredentialSecretCipher);
+    container.registerSingleton(CredentialMaterialResolver, CredentialMaterialResolver);
+    container.registerSingleton(CredentialFieldEnvOverlayService, CredentialFieldEnvOverlayService);
+    container.registerSingleton(CredentialRuntimeMaterialService, CredentialRuntimeMaterialService);
+    container.registerSingleton(WorkflowCredentialNodeResolver, WorkflowCredentialNodeResolver);
+    container.registerSingleton(CredentialInstanceService, CredentialInstanceService);
+    container.registerSingleton(CredentialBindingService, CredentialBindingService);
+    container.registerSingleton(WorkflowActivationPreflightRules, WorkflowActivationPreflightRules);
+    container.registerSingleton(WorkflowActivationPreflight, WorkflowActivationPreflight);
+    container.registerSingleton(CredentialTestService, CredentialTestService);
+    container.registerSingleton(CredentialSessionServiceImpl, CredentialSessionServiceImpl);
     if (!inputs.appConfig.hasConfiguredCredentialSessionServiceRegistration) {
       container.register(CoreTokens.CredentialSessionService, { useToken: CredentialSessionServiceImpl });
     }
-    container.register(OAuth2ProviderRegistry, { useClass: OAuth2ProviderRegistry });
-    container.register(OAuth2ConnectService, { useClass: OAuth2ConnectService });
-    container.register(CodemationFrontendAuthSnapshotFactory, { useClass: CodemationFrontendAuthSnapshotFactory });
-    container.register(FrontendAppConfigFactory, { useClass: FrontendAppConfigFactory });
-    container.register(PublicFrontendBootstrapFactory, { useClass: PublicFrontendBootstrapFactory });
-    container.register(InternalAuthBootstrapFactory, { useClass: InternalAuthBootstrapFactory });
-    container.register(DatabaseMigrations, { useClass: DatabaseMigrations });
-    container.register(FrontendRuntime, { useClass: FrontendRuntime });
-    container.register(WorkerRuntime, { useClass: WorkerRuntime });
-    container.register(DevelopmentSessionBypassVerifier, { useClass: DevelopmentSessionBypassVerifier });
-    container.register(SecureRequestDetector, { useClass: SecureRequestDetector });
-    container.register(InAppCallbackUrlPolicy, { useClass: InAppCallbackUrlPolicy });
-    container.register(AuthSessionCookieFactory, { useClass: AuthSessionCookieFactory });
-    container.register(CodemationBetterAuthBcryptPasswordCodec, { useClass: CodemationBetterAuthBcryptPasswordCodec });
-    container.register(CodemationBetterAuthDatabaseOptionsFactory, {
-      useClass: CodemationBetterAuthDatabaseOptionsFactory,
-    });
-    container.register(UserAccountSessionPolicy, { useClass: UserAccountSessionPolicy });
+    container.registerSingleton(OAuth2ProviderRegistry, OAuth2ProviderRegistry);
+    container.registerSingleton(OAuth2ConnectService, OAuth2ConnectService);
+    container.registerSingleton(CodemationFrontendAuthSnapshotFactory, CodemationFrontendAuthSnapshotFactory);
+    container.registerSingleton(FrontendAppConfigFactory, FrontendAppConfigFactory);
+    container.registerSingleton(PublicFrontendBootstrapFactory, PublicFrontendBootstrapFactory);
+    container.registerSingleton(InternalAuthBootstrapFactory, InternalAuthBootstrapFactory);
+    container.registerSingleton(DatabaseMigrations, DatabaseMigrations);
+    container.registerSingleton(FrontendRuntime, FrontendRuntime);
+    container.registerSingleton(WorkerRuntime, WorkerRuntime);
+    container.registerSingleton(DevelopmentSessionBypassVerifier, DevelopmentSessionBypassVerifier);
+    container.registerSingleton(SecureRequestDetector, SecureRequestDetector);
+    container.registerSingleton(InAppCallbackUrlPolicy, InAppCallbackUrlPolicy);
+    container.registerSingleton(AuthSessionCookieFactory, AuthSessionCookieFactory);
+    container.registerSingleton(CodemationBetterAuthBcryptPasswordCodec, CodemationBetterAuthBcryptPasswordCodec);
+    container.registerSingleton(CodemationBetterAuthDatabaseOptionsFactory, CodemationBetterAuthDatabaseOptionsFactory);
+    container.registerSingleton(UserAccountSessionPolicy, UserAccountSessionPolicy);
     container.register(CodemationBetterAuthBaseUrlPolicy, {
       useFactory: instanceCachingFactory(
         (dependencyContainer) =>
@@ -524,7 +522,7 @@ export class AppContainerFactory {
         return new BetterAuthApiSessionVerifier(runtime, eligibility);
       }),
     });
-    container.register(CodemationSessionVerifier, { useClass: CodemationSessionVerifier });
+    container.registerSingleton(CodemationSessionVerifier, CodemationSessionVerifier);
     container.register(ApplicationTokens.SessionVerifier, {
       useFactory: instanceCachingFactory((dependencyContainer) => {
         const appConfig = dependencyContainer.resolve<AppConfig>(ApplicationTokens.AppConfig);
@@ -564,53 +562,51 @@ export class AppContainerFactory {
   }
 
   private registerRepositoriesAndBuses(container: Container): void {
-    container.register(OtelIdentityFactory, { useClass: OtelIdentityFactory });
-    container.register(TelemetryPrivacyPolicy, { useClass: TelemetryPrivacyPolicy });
-    container.register(TelemetryEnricherChain, { useClass: TelemetryEnricherChain });
-    container.register(TelemetryRetentionTimestampFactory, { useClass: TelemetryRetentionTimestampFactory });
-    container.register(TelemetryQueryService, { useClass: TelemetryQueryService });
-    container.register(NoOpTelemetryExporter, { useClass: NoOpTelemetryExporter });
+    container.registerSingleton(OtelIdentityFactory, OtelIdentityFactory);
+    container.registerSingleton(TelemetryPrivacyPolicy, TelemetryPrivacyPolicy);
+    container.registerSingleton(TelemetryEnricherChain, TelemetryEnricherChain);
+    container.registerSingleton(TelemetryRetentionTimestampFactory, TelemetryRetentionTimestampFactory);
+    container.registerSingleton(TelemetryQueryService, TelemetryQueryService);
+    container.registerSingleton(NoOpTelemetryExporter, NoOpTelemetryExporter);
     container.register(CompositeTelemetryExporter, {
       useFactory: instanceCachingFactory(
         (dependencyContainer) => new CompositeTelemetryExporter([dependencyContainer.resolve(NoOpTelemetryExporter)]),
       ),
     });
-    container.register(OtelExecutionTelemetryFactory, { useClass: OtelExecutionTelemetryFactory });
-    container.register(InMemoryRunTraceContextRepository, { useClass: InMemoryRunTraceContextRepository });
-    container.register(InMemoryTelemetrySpanStore, { useClass: InMemoryTelemetrySpanStore });
-    container.register(InMemoryTelemetryArtifactStore, { useClass: InMemoryTelemetryArtifactStore });
-    container.register(InMemoryTelemetryMetricPointStore, { useClass: InMemoryTelemetryMetricPointStore });
-    container.register(PrismaRunTraceContextRepository, { useClass: PrismaRunTraceContextRepository });
-    container.register(PrismaTelemetrySpanStore, { useClass: PrismaTelemetrySpanStore });
-    container.register(PrismaTelemetryArtifactStore, { useClass: PrismaTelemetryArtifactStore });
-    container.register(PrismaTelemetryMetricPointStore, { useClass: PrismaTelemetryMetricPointStore });
-    container.register(WorkflowDefinitionRepositoryAdapter, { useClass: WorkflowDefinitionRepositoryAdapter });
-    container.register(InMemoryWorkflowRunRepository, { useClass: InMemoryWorkflowRunRepository });
-    container.register(InMemoryTriggerSetupStateRepository, { useClass: InMemoryTriggerSetupStateRepository });
-    container.register(InMemoryCredentialStore, { useClass: InMemoryCredentialStore });
-    container.register(SqlWorkflowRunRepository, { useClass: SqlWorkflowRunRepository });
-    container.register(InMemoryWorkflowDebuggerOverlayRepository, {
-      useClass: InMemoryWorkflowDebuggerOverlayRepository,
-    });
-    container.register(PrismaTriggerSetupStateRepository, { useClass: PrismaTriggerSetupStateRepository });
-    container.register(PrismaWorkflowDebuggerOverlayRepository, { useClass: PrismaWorkflowDebuggerOverlayRepository });
-    container.register(PrismaWorkflowActivationRepository, { useClass: PrismaWorkflowActivationRepository });
-    container.register(InMemoryWorkflowActivationRepository, { useClass: InMemoryWorkflowActivationRepository });
-    container.register(PrismaCredentialStore, { useClass: PrismaCredentialStore });
+    container.registerSingleton(OtelExecutionTelemetryFactory, OtelExecutionTelemetryFactory);
+    container.registerSingleton(InMemoryRunTraceContextRepository, InMemoryRunTraceContextRepository);
+    container.registerSingleton(InMemoryTelemetrySpanStore, InMemoryTelemetrySpanStore);
+    container.registerSingleton(InMemoryTelemetryArtifactStore, InMemoryTelemetryArtifactStore);
+    container.registerSingleton(InMemoryTelemetryMetricPointStore, InMemoryTelemetryMetricPointStore);
+    container.registerSingleton(PrismaRunTraceContextRepository, PrismaRunTraceContextRepository);
+    container.registerSingleton(PrismaTelemetrySpanStore, PrismaTelemetrySpanStore);
+    container.registerSingleton(PrismaTelemetryArtifactStore, PrismaTelemetryArtifactStore);
+    container.registerSingleton(PrismaTelemetryMetricPointStore, PrismaTelemetryMetricPointStore);
+    container.registerSingleton(WorkflowDefinitionRepositoryAdapter, WorkflowDefinitionRepositoryAdapter);
+    container.registerSingleton(InMemoryWorkflowRunRepository, InMemoryWorkflowRunRepository);
+    container.registerSingleton(InMemoryTriggerSetupStateRepository, InMemoryTriggerSetupStateRepository);
+    container.registerSingleton(InMemoryCredentialStore, InMemoryCredentialStore);
+    container.registerSingleton(SqlWorkflowRunRepository, SqlWorkflowRunRepository);
+    container.registerSingleton(InMemoryWorkflowDebuggerOverlayRepository, InMemoryWorkflowDebuggerOverlayRepository);
+    container.registerSingleton(PrismaTriggerSetupStateRepository, PrismaTriggerSetupStateRepository);
+    container.registerSingleton(PrismaWorkflowDebuggerOverlayRepository, PrismaWorkflowDebuggerOverlayRepository);
+    container.registerSingleton(PrismaWorkflowActivationRepository, PrismaWorkflowActivationRepository);
+    container.registerSingleton(InMemoryWorkflowActivationRepository, InMemoryWorkflowActivationRepository);
+    container.registerSingleton(PrismaCredentialStore, PrismaCredentialStore);
     container.register(ApplicationTokens.WorkflowDefinitionRepository, {
       useFactory: instanceCachingFactory(
         (dependencyContainer) =>
           dependencyContainer.resolve(WorkflowDefinitionRepositoryAdapter) as unknown as WorkflowDefinitionRepository,
       ),
     });
-    container.register(InMemoryQueryBus, { useClass: InMemoryQueryBus });
-    container.register(InMemoryCommandBus, { useClass: InMemoryCommandBus });
-    container.register(InMemoryDomainEventBus, { useClass: InMemoryDomainEventBus });
+    container.registerSingleton(InMemoryQueryBus, InMemoryQueryBus);
+    container.registerSingleton(InMemoryCommandBus, InMemoryCommandBus);
+    container.registerSingleton(InMemoryDomainEventBus, InMemoryDomainEventBus);
     for (const handler of AppContainerFactory.queryHandlers) {
-      container.register(ApplicationTokens.QueryHandler, { useClass: handler });
+      container.registerSingleton(ApplicationTokens.QueryHandler, handler);
     }
     for (const handler of AppContainerFactory.commandHandlers) {
-      container.register(ApplicationTokens.CommandHandler, { useClass: handler });
+      container.registerSingleton(ApplicationTokens.CommandHandler, handler);
     }
     container.register(ApplicationTokens.QueryBus, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryQueryBus)),
@@ -629,25 +625,25 @@ export class AppContainerFactory {
   }
 
   private registerApplicationServicesAndRoutes(container: Container): void {
-    container.register(DevBootstrapSummaryAssembler, { useClass: DevBootstrapSummaryAssembler });
-    container.register(DevBootstrapSummaryHttpRouteHandler, { useClass: DevBootstrapSummaryHttpRouteHandler });
-    container.register(AuthHttpRouteHandler, { useClass: AuthHttpRouteHandler });
-    container.register(PublicFrontendBootstrapHttpRouteHandler, { useClass: PublicFrontendBootstrapHttpRouteHandler });
-    container.register(InternalAuthBootstrapHttpRouteHandler, { useClass: InternalAuthBootstrapHttpRouteHandler });
-    container.register(WhitelabelLogoHttpRouteHandler, { useClass: WhitelabelLogoHttpRouteHandler });
+    container.registerSingleton(DevBootstrapSummaryAssembler, DevBootstrapSummaryAssembler);
+    container.registerSingleton(DevBootstrapSummaryHttpRouteHandler, DevBootstrapSummaryHttpRouteHandler);
+    container.registerSingleton(AuthHttpRouteHandler, AuthHttpRouteHandler);
+    container.registerSingleton(PublicFrontendBootstrapHttpRouteHandler, PublicFrontendBootstrapHttpRouteHandler);
+    container.registerSingleton(InternalAuthBootstrapHttpRouteHandler, InternalAuthBootstrapHttpRouteHandler);
+    container.registerSingleton(WhitelabelLogoHttpRouteHandler, WhitelabelLogoHttpRouteHandler);
     for (const registrar of AppContainerFactory.honoRouteRegistrars) {
-      container.register(ApplicationTokens.HonoApiRouteRegistrar, { useClass: registrar });
+      container.registerSingleton(ApplicationTokens.HonoApiRouteRegistrar, registrar);
     }
-    container.register(CodemationHonoApiApp, { useClass: CodemationHonoApiApp });
+    container.registerSingleton(CodemationHonoApiApp, CodemationHonoApiApp);
   }
 
   private registerOperationalInfrastructure(container: Container): void {
     container.register(ApplicationTokens.WorkflowWebsocketPublisher, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowWebsocketServer)),
     });
-    container.register(WorkflowRunEventWebsocketRelay, { useClass: WorkflowRunEventWebsocketRelay });
-    container.register(RunEventBusTelemetryReporter, { useClass: RunEventBusTelemetryReporter });
-    container.register(WorkflowRunRetentionPruneScheduler, { useClass: WorkflowRunRetentionPruneScheduler });
+    container.registerSingleton(WorkflowRunEventWebsocketRelay, WorkflowRunEventWebsocketRelay);
+    container.registerSingleton(RunEventBusTelemetryReporter, RunEventBusTelemetryReporter);
+    container.registerSingleton(WorkflowRunRetentionPruneScheduler, WorkflowRunRetentionPruneScheduler);
   }
 
   private async registerRuntimeInfrastructure(container: Container, appConfig: AppConfig): Promise<PrismaOwnership> {

package/src/bootstrap/CodemationContainerRegistrationRegistrar.ts

@@ -18,9 +18,7 @@ export class CodemationContainerRegistrationRegistrar {
       return;
     }
     if (this.isClassRegistration(registration)) {
-      container.register(registration.token, {
-        useClass: registration.useClass as never,
-      });
+      container.registerSingleton(registration.token as never, registration.useClass as never);
       return;
     }
     container.register(registration.token, {

package/src/infrastructure/config/CodemationPluginRegistrar.ts

@@ -27,17 +27,13 @@ export class CodemationPluginRegistrar {
         loggerFactory: args.loggerFactory,
         registerCredentialType: (type) => args.registerCredentialType(type),
         registerNode: (token, implementation) => {
-          args.container.register(token, {
-            useClass: (implementation ?? token) as never,
-          });
+          args.container.registerSingleton(token as never, (implementation ?? token) as never);
         },
         registerValue: (token, value) => {
           args.container.registerInstance(token, value);
         },
         registerClass: (token, implementation) => {
-          args.container.register(token, {
-            useClass: implementation as never,
-          });
+          args.container.registerSingleton(token as never, implementation as never);
         },
         registerFactory: (token, factory) => {
           args.container.register(token, {

package/src/infrastructure/di/HandlesDomainEventRegistry.ts

@@ -1,4 +1,4 @@
-import { injectable, registry } from "@codemation/core";
+import { container as tsyringeContainer, injectable } from "@codemation/core";
 import type { DomainEvent } from "../../application/bus/DomainEvent";
 import type { DomainEventHandler } from "../../application/bus/DomainEventHandler";
 import { ApplicationTokens } from "../../applicationTokens";
@@ -13,12 +13,10 @@ export class HandlesDomainEvent {
     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);
+      tsyringeContainer.registerSingleton(
+        ApplicationTokens.DomainEventHandler as never,
+        target as unknown as ConcreteType<DomainEventHandler<DomainEvent>>,
+      );
     };
   }
 }

package/src/infrastructure/persistence/PrismaWorkflowRunRepository.ts

@@ -611,6 +611,14 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
     }
     let cIdx = 0;
     for (const inv of state.connectionInvocations ?? []) {
+      if (inv.runId !== state.runId) {
+        // Defense-in-depth: `invocationId` is a global primary key in `ExecutionInstance`.
+        // A record whose `runId` differs from the current run belongs to another run and
+        // would collide on insert. `RunStartService.createRunCurrentState` already prevents
+        // carry-over; we skip here so any other accidental carry-over path self-heals
+        // instead of crashing the save.
+        continue;
+      }
       rows.push({
         instanceId: inv.invocationId,
         runId: state.runId,

package/src/presentation/http/hono/registrars/AuthHonoApiRouteRegistrar.ts

@@ -1,12 +1,10 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { CodemationBetterAuthRuntime } from "../../../../infrastructure/auth/CodemationBetterAuthRuntime";
 import { AuthHttpRouteHandler } from "../../routeHandlers/AuthHttpRouteHandlerFactory";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: AuthHonoApiRouteRegistrar }])
 export class AuthHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(
     @inject(AuthHttpRouteHandler) private readonly handler: AuthHttpRouteHandler,

package/src/presentation/http/hono/registrars/BinaryHonoApiRouteRegistrar.ts

@@ -1,12 +1,10 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { BinaryHttpRouteHandler } from "../../routeHandlers/BinaryHttpRouteHandlerFactory";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 /** Run-scoped binary content. Workflow overlay binary GET/POST are registered on {@link CodemationHonoApiApp} after route registrars. */
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: BinaryHonoApiRouteRegistrar }])
 export class BinaryHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(BinaryHttpRouteHandler) private readonly handler: BinaryHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/BootstrapHonoApiRouteRegistrar.ts

@@ -1,14 +1,12 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
 
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { ApiPaths } from "../../ApiPaths";
 import { InternalAuthBootstrapHttpRouteHandler } from "../../routeHandlers/InternalAuthBootstrapHttpRouteHandler";
 import { PublicFrontendBootstrapHttpRouteHandler } from "../../routeHandlers/PublicFrontendBootstrapHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: BootstrapHonoApiRouteRegistrar }])
 export class BootstrapHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(
     @inject(PublicFrontendBootstrapHttpRouteHandler)

package/src/presentation/http/hono/registrars/CredentialHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { CredentialHttpRouteHandler } from "../../routeHandlers/CredentialHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: CredentialHonoApiRouteRegistrar }])
 export class CredentialHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(CredentialHttpRouteHandler) private readonly handler: CredentialHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/DevHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { DevBootstrapSummaryHttpRouteHandler } from "../../routeHandlers/DevBootstrapSummaryHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: DevHonoApiRouteRegistrar }])
 export class DevHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(
     @inject(DevBootstrapSummaryHttpRouteHandler) private readonly handler: DevBootstrapSummaryHttpRouteHandler,

package/src/presentation/http/hono/registrars/OAuth2HonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { OAuth2HttpRouteHandler } from "../../routeHandlers/OAuth2HttpRouteHandlerFactory";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: OAuth2HonoApiRouteRegistrar }])
 export class OAuth2HonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(OAuth2HttpRouteHandler) private readonly handler: OAuth2HttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/RunHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { RunHttpRouteHandler } from "../../routeHandlers/RunHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: RunHonoApiRouteRegistrar }])
 export class RunHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(RunHttpRouteHandler) private readonly handler: RunHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/TelemetryHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { TelemetryHttpRouteHandler } from "../../routeHandlers/TelemetryHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: TelemetryHonoApiRouteRegistrar }])
 export class TelemetryHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(TelemetryHttpRouteHandler) private readonly handler: TelemetryHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/UserHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { UserHttpRouteHandler } from "../../routeHandlers/UserHttpRouteHandlerFactory";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: UserHonoApiRouteRegistrar }])
 export class UserHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(UserHttpRouteHandler) private readonly handler: UserHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/WebhookHonoApiRouteRegistrar.ts

@@ -1,12 +1,10 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import type { Context } from "hono";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { WebhookHttpRouteHandler } from "../../routeHandlers/WebhookHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: WebhookHonoApiRouteRegistrar }])
 export class WebhookHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(WebhookHttpRouteHandler) private readonly handler: WebhookHttpRouteHandler) {}
 

package/src/presentation/http/hono/registrars/WhitelabelHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { WhitelabelLogoHttpRouteHandler } from "../../routeHandlers/WhitelabelLogoHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: WhitelabelHonoApiRouteRegistrar }])
 export class WhitelabelHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(
     @inject(WhitelabelLogoHttpRouteHandler)

package/src/presentation/http/hono/registrars/WorkflowHonoApiRouteRegistrar.ts

@@ -1,11 +1,9 @@
-import { inject, injectable, registry } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
 import { Hono } from "hono";
-import { ApplicationTokens } from "../../../../applicationTokens";
 import { WorkflowHttpRouteHandler } from "../../routeHandlers/WorkflowHttpRouteHandler";
 import type { HonoApiRouteRegistrar } from "../HonoApiRouteRegistrar";
 
 @injectable()
-@registry([{ token: ApplicationTokens.HonoApiRouteRegistrar, useClass: WorkflowHonoApiRouteRegistrar }])
 export class WorkflowHonoApiRouteRegistrar implements HonoApiRouteRegistrar {
   constructor(@inject(WorkflowHttpRouteHandler) private readonly handler: WorkflowHttpRouteHandler) {}