ddd-ts-kit 0.0.0-stage → 0.1.1

package/templates/init/e2e/start-application.database.ts.tpl

@@ -0,0 +1,142 @@
+{{#if authz.rebac}}
+import type { RelationTuple } from '@ddd-ts-kit/auth/rebac';
+{{/if}}
+import type { IntegrationEventSubscriber } from '@ddd-ts-kit/kernel';
+import { createHttpClient, type HttpClient } from '@ddd-ts-kit/testing/e2e';
+{{#if authz.rebac}}
+import { relationTuples } from '{{alias.platform}}/auth/relation-tuples.js';
+{{/if}}
+import { composeApplication } from '{{alias.platform}}/compose-application.js';
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+import { loadConfig } from '{{alias.platform}}/config/load-config.js';
+import { openTestDatabase, type TestDatabase } from '{{alias.platform}}/database/open-test-database.js';
+{{#if broker.provided}}
+import { createEventProvider } from '{{alias.platform}}/events/create-event-provider.js';
+import type { EventProvider } from '{{alias.platform}}/events/event-provider.js';
+{{/if}}
+import { inProcessEvents } from '{{alias.platform}}/events/in-process-events.js';
+{{#if events.outbox}}
+import { startOutboxRelay } from '{{alias.platform}}/events/start-outbox-relay.js';
+{{/if}}
+import { startHttpServer } from '{{alias.platform}}/http/start-http-server.js';
+{{#if cache.redis}}
+import { openRedis } from '{{alias.platform}}/redis/open-redis.js';
+{{/if}}
+import { createCredentials, type Credentials, type TestActor } from '{{alias.test}}/e2e/support/create-credentials.js';
+{{#if broker.addressed}}
+{{#if redis.server}}
+import { noBroker, noRedis, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/if}}
+{{#unless redis.server}}
+import { noBroker, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/unless}}
+{{/if}}
+{{#unless broker.addressed}}
+{{#if redis.server}}
+import { noRedis, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/if}}
+{{#unless redis.server}}
+import { testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/unless}}
+{{/unless}}
+
+/** The whole application, real adapters included, as a client and another context see it. */
+export interface RunningApplication {
+  readonly client: HttpClient;
+  /** Subscribe here (`collectEvents`) to assert the integration events the application publishes. */
+  readonly events: IntegrationEventSubscriber;
+
+  /** A client presenting the credential of `actor`; `client` itself presents none. */
+  as(actor: TestActor): Promise<HttpClient>;
+{{#if authz.rebac}}
+
+  /** Stores a relationship, as the application does when an element is created or shared. */
+  relate(tuple: RelationTuple): Promise<void>;
+{{/if}}
+
+  /** Empties the database: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/**
+ * Starts the application on a free port. The database is PostgreSQL in process unless
+ * DATABASE_URL names a migrated server (`npm run infra:up && npm run db:migrate`).
+ */
+export async function startApplication(): Promise<RunningApplication> {
+  // An empty variable (a blank line of .env) means the same as none.
+  const url = process.env['DATABASE_URL'] === '' ? undefined : process.env['DATABASE_URL'];
+  const database = await openTestDatabase(url);
+  const config = loadConfig(testEnvironment({ DATABASE_URL: url ?? 'postgres://in-process/tests' }));
+  const credentials = await createCredentials();
+  const started = await start(database, config, credentials);
+
+  return {
+    client: started.client,
+    events: started.events,
+    as: async (actor) => started.client.withHeaders(await credentials.headersOf(actor)),
+{{#if authz.rebac}}
+    relate: (tuple) => relationTuples.write([tuple]),
+{{/if}}
+    reset: () => database.reset(),
+    close: () => started.close(),
+  };
+}
+
+interface Started {
+  readonly client: HttpClient;
+  readonly events: IntegrationEventSubscriber;
+
+  close(): Promise<void>;
+}
+
+/** The application on the test database, listening on a free port; closing it closes the database last. */
+async function start(database: TestDatabase, config: AppConfig, credentials: Credentials): Promise<Started> {
+{{#if cache.redis}}
+  const redis = config.redisUrl === noRedis ? undefined : openRedis(config);
+
+{{/if}}
+  const application = composeApplication(database.persistence, {
+    events: {{#if broker.provided}}eventsOf(config){{/if}}{{#unless broker.provided}}inProcessEvents(){{/unless}},
+    authenticator: credentials.authenticator,
+{{#if cache.redis}}
+    ...(redis === undefined ? {} : { redis }),
+{{/if}}
+  });
+
+  await application.start();
+
+{{#if events.outbox}}
+  const relay = startOutboxRelay({
+    store: database.persistence.outbox,
+    publisher: application.eventBus,
+    intervalMs: 20,
+    logger: application.logger,
+  });
+
+{{/if}}
+  const server = await startHttpServer(application, config);
+
+  return {
+    client: createHttpClient('http://127.0.0.1:' + server.port),
+    events: application.eventSubscriber,
+    close: async () => {
+      await server.close();
+{{#if events.outbox}}
+      await relay.stop();
+{{/if}}
+      await application.stop();
+{{#if cache.redis}}
+      await redis?.close();
+{{/if}}
+      await database.close();
+    },
+  };
+}
+{{#if broker.provided}}
+
+function eventsOf(config: AppConfig): EventProvider {
+  return {{broker.inProcessWhen}} ? inProcessEvents() : createEventProvider(config);
+}
+{{/if}}

package/templates/init/e2e/start-application.memory.ts.tpl

@@ -0,0 +1,146 @@
+{{#if authz.rebac}}
+import type { RelationTuple } from '@ddd-ts-kit/auth/rebac';
+{{/if}}
+import type { IntegrationEventSubscriber } from '@ddd-ts-kit/kernel';
+import { createHttpClient, type HttpClient } from '@ddd-ts-kit/testing/e2e';
+{{#if authz.rebac}}
+import { relationTuples } from '{{alias.platform}}/auth/relation-tuples.js';
+{{/if}}
+import { composeApplication } from '{{alias.platform}}/compose-application.js';
+{{#if broker.provided}}
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+{{/if}}
+import { loadConfig } from '{{alias.platform}}/config/load-config.js';
+import { openPersistence } from '{{alias.platform}}/database/open-persistence.js';
+{{#if broker.provided}}
+import { createEventProvider } from '{{alias.platform}}/events/create-event-provider.js';
+import type { EventProvider } from '{{alias.platform}}/events/event-provider.js';
+{{/if}}
+import { inProcessEvents } from '{{alias.platform}}/events/in-process-events.js';
+{{#if events.outbox}}
+import { startOutboxRelay } from '{{alias.platform}}/events/start-outbox-relay.js';
+{{/if}}
+import { startHttpServer } from '{{alias.platform}}/http/start-http-server.js';
+{{#if cache.redis}}
+import { openRedis } from '{{alias.platform}}/redis/open-redis.js';
+{{/if}}
+import { createCredentials, type Credentials, type TestActor } from '{{alias.test}}/e2e/support/create-credentials.js';
+{{#if broker.addressed}}
+{{#if redis.server}}
+import { noBroker, noRedis, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/if}}
+{{#unless redis.server}}
+import { noBroker, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/unless}}
+{{/if}}
+{{#unless broker.addressed}}
+{{#if redis.server}}
+import { noRedis, testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/if}}
+{{#unless redis.server}}
+import { testEnvironment } from '{{alias.test}}/e2e/support/test-environment.js';
+{{/unless}}
+{{/unless}}
+
+/** The whole application as a client and another context see it. */
+export interface RunningApplication {
+  /** Read it again after `reset`: the application was started anew. */
+  readonly client: HttpClient;
+  /** Subscribe here (`collectEvents`) to assert the integration events the application publishes. */
+  readonly events: IntegrationEventSubscriber;
+
+  /** A client presenting the credential of `actor`; `client` itself presents none. */
+  as(actor: TestActor): Promise<HttpClient>;
+{{#if authz.rebac}}
+
+  /** Stores a relationship, as the application does when an element is created or shared. */
+  relate(tuple: RelationTuple): Promise<void>;
+{{/if}}
+
+  /** Starts from nothing again: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/** State lives in memory, so a clean state is a new application on a new free port. */
+export async function startApplication(): Promise<RunningApplication> {
+  const credentials = await createCredentials();
+  let current = await start(credentials);
+
+  return {
+    get client() {
+      return current.client;
+    },
+    get events() {
+      return current.events;
+    },
+    as: async (actor) => current.client.withHeaders(await credentials.headersOf(actor)),
+{{#if authz.rebac}}
+    relate: (tuple) => relationTuples.write([tuple]),
+{{/if}}
+    reset: async () => {
+      await current.close();
+      current = await start(credentials);
+    },
+    close: () => current.close(),
+  };
+}
+
+interface Started {
+  readonly client: HttpClient;
+  readonly events: IntegrationEventSubscriber;
+
+  close(): Promise<void>;
+}
+
+async function start(credentials: Credentials): Promise<Started> {
+  const persistence = openPersistence();
+  const config = loadConfig(testEnvironment());
+{{#if cache.redis}}
+  const redis = config.redisUrl === noRedis ? undefined : openRedis(config);
+{{/if}}
+
+  const application = composeApplication(persistence, {
+    events: {{#if broker.provided}}eventsOf(config){{/if}}{{#unless broker.provided}}inProcessEvents(){{/unless}},
+    authenticator: credentials.authenticator,
+{{#if cache.redis}}
+    ...(redis === undefined ? {} : { redis }),
+{{/if}}
+  });
+
+  await application.start();
+
+{{#if events.outbox}}
+  const relay = startOutboxRelay({
+    store: persistence.outbox,
+    publisher: application.eventBus,
+    intervalMs: 20,
+    logger: application.logger,
+  });
+
+{{/if}}
+  const server = await startHttpServer(application, config);
+
+  return {
+    client: createHttpClient('http://127.0.0.1:' + server.port),
+    events: application.eventSubscriber,
+    close: async () => {
+      await server.close();
+{{#if events.outbox}}
+      await relay.stop();
+{{/if}}
+      await application.stop();
+{{#if cache.redis}}
+      await redis?.close();
+{{/if}}
+      await persistence.close();
+    },
+  };
+}
+{{#if broker.provided}}
+
+function eventsOf(config: AppConfig): EventProvider {
+  return {{broker.inProcessWhen}} ? inProcessEvents() : createEventProvider(config);
+}
+{{/if}}

package/templates/init/e2e/story-of.ts.tpl

@@ -0,0 +1,19 @@
+import type { SpanNode } from '@ddd-ts-kit/tracing/testing';
+
+/**
+ * A trace as the business reads it: without the calls an adapter makes on itself (the `save` of
+ * a repository calling its own `insert`), which say how the adapter is written, not what
+ * happened. What is left is asserted with `expectSpanTree`.
+ */
+export function storyOf(trace: readonly SpanNode[]): SpanNode[] {
+  return trace.map((span) => ({
+    ...span,
+    children: storyOf(span.children.filter((child) => !isOwnCall(span, child))),
+  }));
+}
+
+function isOwnCall(caller: SpanNode, called: SpanNode): boolean {
+  const adapter = /^(?:repository|gateway|external) [^.]+\./.exec(caller.name)?.[0];
+
+  return adapter !== undefined && called.name.startsWith(adapter);
+}

package/templates/init/e2e/test-environment.ts.tpl

@@ -0,0 +1,33 @@
+import { authEnvironment } from '{{alias.test}}/e2e/support/auth-environment.js';
+{{#if broker.addressed}}
+
+/** Without {{broker.variable}} (`npm run infra:up` gives one) the events stay in the process: the same ports, no broker. */
+export const noBroker = '{{broker.absent}}';
+{{/if}}
+{{#if redis.server}}
+
+/** Without REDIS_URL (`npm run infra:up` gives one) what lives on the Redis protocol server stays in the memory of the process: the same ports, no server. */
+export const noRedis = 'redis://in-process/tests';
+{{/if}}
+
+type Variables = Readonly<Record<string, string | undefined>>;
+
+/** The environment of an application under test: a free port, the settings of the test credentials, and what stands for an absent server. */
+export function testEnvironment(overrides: Variables = {}): Variables {
+  return {
+    ...process.env,
+    ...authEnvironment,
+    NODE_ENV: 'test',
+    PORT: '0',
+    {{#if broker.addressed}}
+    {{broker.variable}}: (process.env['{{broker.variable}}'] ?? '') || noBroker,
+    {{/if}}
+    {{#if redis.server}}
+    REDIS_URL: (process.env['REDIS_URL'] ?? '') || noRedis,
+    {{/if}}
+    {{#if cache.rateLimit}}
+    RATE_LIMIT_MAX: process.env['RATE_LIMIT_MAX'] ?? '1000000',
+    {{/if}}
+    ...overrides,
+  };
+}

package/templates/init/e2e/vitest.e2e.config.ts.tpl

@@ -0,0 +1,25 @@
+{{#if decorators.standard}}
+import { decorators } from '@ddd-ts-kit/testing/vitest';
+{{/if}}
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  {{#if decorators.standard}}
+  // The application under test holds classes that carry standard decorators.
+  plugins: [decorators({ compiler: '@typescript/native' })],
+  {{/if}}
+  // An import alias is resolved from the "paths" of tsconfig.json, which name the sources.
+  resolve: { tsconfigPaths: true },
+  test: {
+    include: ['test/e2e/**/*.e2e.spec.ts'],
+    {{#if assembly.discovery}}
+    // Discovery imports the role files of a context itself: inlined, the package loads them through the runner, which compiles them.
+    server: { deps: { inline: ['@ddd-ts-kit/di'] } },
+    {{/if}}
+    // Each file starts its own application; on a shared server (DATABASE_URL) they would
+    // empty each other's tables, so they run one after the other there.
+    fileParallelism: (process.env['DATABASE_URL'] ?? '') === '',
+    testTimeout: 20_000,
+    hookTimeout: 30_000,
+  },
+});

package/templates/init/gitignore.tpl

@@ -0,0 +1,9 @@
+node_modules
+dist
+/coverage/
+.env
+*.tsbuildinfo
+.ddd-ts-kit/
+{{#if orm.prisma}}
+generated
+{{/if}}

package/templates/init/jest.config.js.tpl

@@ -0,0 +1,30 @@
+import { governedJestCoverage, unaffectedContexts } from '@ddd-ts-kit/testing/coverage';
+
+export default {
+  testEnvironment: 'node',
+  // Jest does not read tsconfig: the import aliases of its "paths", repeated here, and held equal by `ddd-ts-kit check` (imports/alias-declared).
+  moduleNameMapper: {
+    {{alias.jestMapper}}
+  },
+  testMatch: ['<rootDir>/{{config.sourceRoot}}/**/*.spec.ts', '<rootDir>/test/architecture/**/*.spec.ts'],
+  // A pull request names the contexts its change reaches (DDD_TS_KIT_AFFECTED, from `ddd-ts-kit affected`): the specs of the others are left to the default branch.
+  testPathIgnorePatterns: ['/node_modules/', ...unaffectedContexts().map((directory) => `/${directory}`)],
+  extensionsToTreatAsEsm: ['.ts'],
+  transform: {
+    '^.+\\.ts$': [
+      '@swc/jest',
+      {
+        jsc: {
+          parser: { syntax: 'typescript', decorators: true },
+          transform: { legacyDecorator: true, decoratorMetadata: true },
+          target: 'es2022',
+        },
+      },
+    ],
+  },
+  coverageProvider: 'v8',
+  coverageReporters: ['text', 'cobertura', 'lcov'],
+  coverageDirectory: 'coverage',
+  // What is measured and the floor of each layer come from "coverage" in ddd-ts-kit.config.json, the reference when it is absent: a threshold is written nowhere else.
+  ...governedJestCoverage(),
+};

package/templates/init/main.ts.tpl

@@ -0,0 +1,98 @@
+// Imported first on purpose: instrumentation has to be installed before any module it patches is loaded.
+import { tracing } from '{{alias.platform}}/tracing.js';
+{{#if errors.sentry}}
+// Imported second on purpose: a failure while the rest of the application loads is already reported.
+import { errors } from '{{alias.platform}}/errors.js';
+{{/if}}
+{{#if http.any}}
+import { createAuthenticator } from '{{alias.platform}}/auth/create-authenticator.js';
+{{/if}}
+import { composeApplication } from '{{alias.platform}}/compose-application.js';
+import { loadConfig } from '{{alias.platform}}/config/load-config.js';
+import { openPersistence } from '{{alias.platform}}/database/open-persistence.js';
+import { {{events.providerName}} } from '{{alias.platform}}/events/{{events.providerFile}}.js';
+{{#if events.outbox}}
+import { startOutboxRelay } from '{{alias.platform}}/events/start-outbox-relay.js';
+{{/if}}
+{{#if http.any}}
+import { startHttpServer } from '{{alias.platform}}/http/start-http-server.js';
+{{/if}}
+import { jobSettings } from '{{alias.platform}}/job-settings.js';
+{{#if cache.redis}}
+import { openRedis } from '{{alias.platform}}/redis/open-redis.js';
+{{/if}}
+
+const config = loadConfig(process.env);
+{{#if persistence.needsUrl}}
+const persistence = {{persistence.await}}openPersistence(config);
+{{/if}}
+{{#unless persistence.needsUrl}}
+const persistence = openPersistence();
+{{/unless}}
+{{#if cache.redis}}
+const redis = openRedis(config);
+{{/if}}
+
+const application = composeApplication(persistence, {
+  events: {{events.provider}},
+  {{#if errors.sentry}}
+  errors,
+  {{/if}}
+  {{#if http.any}}
+  authenticator: createAuthenticator(config),
+  {{/if}}
+  log: { ...config.log, service: config.serviceName, environment: config.environment },
+  traceConsumers: config.tracing.consumers,
+  resilience: config.resilience,
+  jobs: { start: config.runJobs, settings: jobSettings(process.env) },
+  {{#if cache.redis}}
+  redis,
+  {{/if}}
+});
+
+await application.start();
+
+{{#if events.outbox}}
+const relay = startOutboxRelay({
+  store: persistence.outbox,
+  publisher: application.eventBus,
+  intervalMs: config.outboxRelayIntervalMs,
+  logger: application.logger,
+  {{#if errors.sentry}}
+  errors,
+  {{/if}}
+  {{#if cache.relaySignal}}
+  wakeOn: redis.relaySignal,
+  {{/if}}
+  {{#if persistence.signals}}
+  wakeOn: persistence.relaySignal,
+  {{/if}}
+});
+
+{{/if}}
+{{#if http.any}}
+const server = await startHttpServer(application, config);
+
+application.logger.info('listening', { port: server.port });
+{{/if}}
+{{#unless http.any}}
+application.logger.info('started');
+{{/unless}}
+
+process.once('SIGTERM', () => void shutdown());
+process.once('SIGINT', () => void shutdown());
+
+async function shutdown(): Promise<void> {
+  {{#if http.any}}
+  await server.close();
+  {{/if}}
+  {{#if events.outbox}}
+  await relay.stop();
+  {{/if}}
+  await application.stop();
+  {{#if cache.redis}}
+  await redis.close();
+  {{/if}}
+  await persistence.close();
+  await tracing.shutdown();
+}

package/templates/init/platform/audit/audit.module.manual.ts.tpl

@@ -0,0 +1,39 @@
+import { requires, type UseCaseDeclaration } from '@ddd-ts-kit/auth';
+import type { Route } from '@ddd-ts-kit/http';
+import type { Platform } from '{{alias.platform}}/platform.js';
+import { auditPermissions } from '{{alias.platform}}/audit/audit.permissions.js';
+import { SearchAuditEntriesHandler } from '{{alias.platform}}/audit/search-audit-entries.handler.js';
+import { SearchAuditEntriesQuery } from '{{alias.platform}}/audit/search-audit-entries.query.js';
+import { searchAuditEntriesRoute } from '{{alias.platform}}/audit/search-audit-entries.route.js';
+
+interface AuditWiring {
+  readonly name: string;
+  readonly useCases: readonly UseCaseDeclaration[];
+  readonly routes: readonly Route[];
+}
+
+/**
+ * The read side of the audit trail: a capability of the platform, not a bounded context. It has
+ * no model of its own, only one protected query over the `AuditReader` port, registered like any
+ * use case so that reading the trail is authorized and recorded.
+ */
+export function auditModule(platform: Platform): AuditWiring {
+  platform.queries.register(SearchAuditEntriesQuery, new SearchAuditEntriesHandler(platform.audit.trail), {
+    context: 'audit',
+  });
+
+  return {
+    name: 'audit',
+    {{#if authz.rebac}}
+    useCases: [
+      requires(SearchAuditEntriesQuery, auditPermissions['trail.read'], {
+        resource: () => ({ type: 'context', id: 'audit' }),
+      }),
+    ],
+    {{/if}}
+    {{#unless authz.rebac}}
+    useCases: [requires(SearchAuditEntriesQuery, auditPermissions['trail.read'])],
+    {{/unless}}
+    routes: [searchAuditEntriesRoute(platform.queries)],
+  };
+}

package/templates/init/platform/audit/audit.module.tsyringe.ts.tpl

@@ -0,0 +1,47 @@
+import { AuditReader, AuditTrail } from '@ddd-ts-kit/audit';
+import { defineContextModule, type ContextModule } from '@ddd-ts-kit/di';
+import { subscribeAll } from '@ddd-ts-kit/events';
+import { EventSubscribers } from '@ddd-ts-kit/kernel';
+{{#if audit.route}}
+import { auditPermissions } from '{{alias.platform}}/audit/audit.permissions.js';
+{{/if}}
+import type { Audit } from '{{alias.platform}}/audit/create-audit.js';
+{{#if audit.route}}
+import { SearchAuditEntriesHandler } from '{{alias.platform}}/audit/search-audit-entries.handler.js';
+import { SearchAuditEntriesQuery } from '{{alias.platform}}/audit/search-audit-entries.query.js';
+{{/if}}
+
+/**
+ * The audit trail as a capability of the platform, not a bounded context: the store behind its
+ * two ports, the subscription to every declared integration event, under a name of its own{{#if audit.route}}, and
+ * its read side, one protected query registered like any use case so that reading the trail is
+ * authorized and recorded{{/if}}.
+ */
+export function auditModule(audit: Audit): ContextModule {
+  return defineContextModule({
+    name: 'audit',
+    register(builder) {
+      builder.bind(AuditTrail).toValue(audit.trail);
+      builder.bind(AuditReader).toValue(audit.trail);
+{{#if audit.route}}
+{{#if authz.rebac}}
+
+      builder
+        .query(SearchAuditEntriesQuery)
+        .requires(auditPermissions['trail.read'], { resource: () => ({ type: 'context', id: 'audit' }) })
+        .handledBy(SearchAuditEntriesHandler, [AuditReader]);
+{{/if}}
+{{#unless authz.rebac}}
+
+      builder
+        .query(SearchAuditEntriesQuery)
+        .requires(auditPermissions['trail.read'])
+        .handledBy(SearchAuditEntriesHandler, [AuditReader]);
+{{/unless}}
+{{/if}}
+    },
+    onStart({ resolve }) {
+      subscribeAll(resolve(EventSubscribers).forContext(audit.consumer), audit.subscriptions);
+    },
+  });
+}

package/templates/init/platform/audit/audit.permissions.ts.tpl

@@ -0,0 +1,6 @@
+import { definePermissions } from '@ddd-ts-kit/auth';
+
+/** Reading the trail is itself a sensitive act: one permission, and every allowed read is recorded. */
+export const auditPermissions = definePermissions('audit', {
+  'trail.read': { description: 'Read the audit trail' },
+});

package/templates/init/platform/audit/audited-events.ts.tpl

@@ -0,0 +1,9 @@
+import { createEventRegistry } from '@ddd-ts-kit/events';
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+/** Every integration event the contexts declare: the audit trail records that each one occurred. `generate integration-event` adds to it. */
+export const auditedEvents = createEventRegistry([
+  // ddd-ts-kit:events
+  // /ddd-ts-kit:events
+]);