ddd-ts-kit 0.0.0-stage → 0.1.0

package/templates/init/platform/database/database.drizzle.ts.tpl

@@ -0,0 +1,9 @@
+import type { PgQueryResultHKT } from 'drizzle-orm/pg-core';
+import { DrizzleContext } from '@ddd-ts-kit/drizzle/postgres';
+
+/**
+ * The storage of the application, as a repository adapter names it in its dependency list. Typed
+ * on the driver-neutral base, so that the same repositories run on node-postgres in production
+ * and on PGlite in the tests.
+ */
+export abstract class Database extends DrizzleContext<PgQueryResultHKT> {}

package/templates/init/platform/database/database.prisma.ts.tpl

@@ -0,0 +1,5 @@
+import { PrismaContext } from '@ddd-ts-kit/prisma';
+import type { Prisma } from '{{alias.generated}}/prisma/client.js';
+
+/** The storage of the application, as a repository adapter names it in its dependency list: the transaction client of the current unit of work, or the root client. */
+export abstract class Database extends PrismaContext<Prisma.TransactionClient> {}

package/templates/init/platform/database/drizzle.config.ts.tpl

@@ -0,0 +1,8 @@
+import type { Config } from 'drizzle-kit';
+
+export default {
+  dialect: 'postgresql',
+  schema: './{{config.platformDir}}/database/schema.ts',
+  out: './migrations',
+  dbCredentials: { url: process.env['DATABASE_URL'] ?? '' },
+} satisfies Config;

package/templates/init/platform/database/inert-persistence.memory.ts.tpl

@@ -0,0 +1,7 @@
+import { openPersistence } from '{{alias.platform}}/database/open-persistence.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/** For the scripts that only list routes: nothing to connect to here. */
+export function inertPersistence(): Persistence {
+  return openPersistence();
+}

package/templates/init/platform/database/inert-persistence.pooled.ts.tpl

@@ -0,0 +1,10 @@
+import { openPersistence } from '{{alias.platform}}/database/open-persistence.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/**
+ * For the script that only lists routes: the pool connects on the first query,
+ * and none is ever sent, so no database has to be reachable to generate the contracts.
+ */
+export function inertPersistence(): Persistence {
+  return openPersistence({ databaseUrl: 'postgres://unused:unused@127.0.0.1:1/unused' });
+}

package/templates/init/platform/database/inert-persistence.prisma.ts.tpl

@@ -0,0 +1,11 @@
+import { createClient } from '{{alias.platform}}/database/create-client.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/**
+ * For the script that only lists routes: the client connects on the first query,
+ * and none is ever sent, so no database has to be reachable to generate the contracts.
+ */
+export function inertPersistence(): Persistence {
+  return persistenceOver(createClient('postgres://unused:unused@127.0.0.1:1/unused'));
+}

package/templates/init/platform/database/inert-persistence.typeorm.ts.tpl

@@ -0,0 +1,11 @@
+import { createDataSource } from '{{alias.platform}}/database/create-data-source.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/**
+ * For the script that only lists routes: the data source is never initialised,
+ * and no query is ever sent, so no database has to be reachable to generate the contracts.
+ */
+export function inertPersistence(): Persistence {
+  return persistenceOver(createDataSource('postgres://unused:unused@127.0.0.1:1/unused'));
+}

package/templates/init/platform/database/knexfile.js.tpl

@@ -0,0 +1,9 @@
+import process from 'node:process';
+
+// Read by the knex CLI (`npm run db:migrate`, `npm run db:generate <name>`). The migrations
+// call the compiled schema of the application: run `npm run build` first.
+export default {
+  client: 'pg',
+  connection: process.env.DATABASE_URL,
+  migrations: { directory: './migrations', loadExtensions: ['.js'] },
+};

package/templates/init/platform/database/migration.knex.js.tpl

@@ -0,0 +1,8 @@
+// A migration is run by the knex CLI under plain node, which resolves no alias: it names the compiled schema by its path.
+import { createTables } from '../dist/{{config.platformDir}}/database/schema.js';
+
+export const up = (knex) => createTables(knex);
+
+export const down = () => {
+  throw new Error('The initial migration is not reverted: drop the database instead.');
+};

package/templates/init/platform/database/open-persistence.contract.spec.ts.tpl

@@ -0,0 +1,17 @@
+import { afterEach, beforeEach, describe, expect, it } from '{{tests.module}}';
+import { outboxStoreContract, processedEventStoreContract } from '@ddd-ts-kit/testing/contracts';
+import { openPersistence } from '{{alias.platform}}/database/open-persistence.js';
+
+const runner = { describe, it, expect, beforeEach, afterEach };
+
+// TODO(platform): once the stores are yours, set `leaseMs` to the lease your outbox store is configured with.
+outboxStoreContract(runner, {
+  name: 'The outbox store of the platform',
+  createStore: () => openPersistence().outbox,
+  leaseMs: 30_000,
+});
+
+processedEventStoreContract(runner, {
+  name: 'The processed-event store of the platform',
+  createStore: () => openPersistence().processedEvents,
+});

package/templates/init/platform/database/open-persistence.memory.ts.tpl

@@ -0,0 +1,35 @@
+{{#if persistence.signals}}
+import { InMemoryOutboxStore, InMemoryRelaySignal } from '@ddd-ts-kit/events';
+{{/if}}
+{{#unless persistence.signals}}
+import { InMemoryOutboxStore } from '@ddd-ts-kit/events';
+{{/unless}}
+import { InMemoryProcessedEventStore, InMemoryUnitOfWork } from '@ddd-ts-kit/kernel';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+{{#if orm.custom}}
+/**
+ * Starts in memory. TODO(platform): replace each of the three adapters by the one of your
+ * storage: a UnitOfWork keeping its transaction in an AsyncLocalStorage, an OutboxStore and a
+ * ProcessedEventStore writing in that transaction. open-persistence.contract.spec.ts holds
+ * them to the contract suites; repositories then receive your connection from here.
+ */
+{{/if}}
+export function openPersistence(): Persistence {
+{{#if persistence.signals}}
+  const relaySignal = new InMemoryRelaySignal();
+
+  return {
+    unitOfWork: new InMemoryUnitOfWork(),
+    outbox: new InMemoryOutboxStore({ signal: relaySignal }),
+    relaySignal,
+{{/if}}
+{{#unless persistence.signals}}
+  return {
+    unitOfWork: new InMemoryUnitOfWork(),
+    outbox: new InMemoryOutboxStore(),
+{{/unless}}
+    processedEvents: new InMemoryProcessedEventStore(),
+    close: () => Promise.resolve(),
+  };
+}

package/templates/init/platform/database/open-persistence.pooled.ts.tpl

@@ -0,0 +1,9 @@
+import { connectToDatabase } from '{{alias.platform}}/database/connect-to-database.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+export function openPersistence(config: { readonly databaseUrl: string }): Persistence {
+  const connection = connectToDatabase(config.databaseUrl);
+
+  return persistenceOver(connection.db, () => connection.close());
+}

package/templates/init/platform/database/open-persistence.prisma.ts.tpl

@@ -0,0 +1,11 @@
+import { createClient } from '{{alias.platform}}/database/create-client.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+export async function openPersistence(config: { readonly databaseUrl: string }): Promise<Persistence> {
+  const client = createClient(config.databaseUrl);
+
+  await client.$connect();
+
+  return persistenceOver(client);
+}

package/templates/init/platform/database/open-persistence.typeorm.ts.tpl

@@ -0,0 +1,11 @@
+import { createDataSource } from '{{alias.platform}}/database/create-data-source.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+export async function openPersistence(config: { readonly databaseUrl: string }): Promise<Persistence> {
+  const dataSource = createDataSource(config.databaseUrl);
+
+  await dataSource.initialize();
+
+  return persistenceOver(dataSource);
+}

package/templates/init/platform/database/open-test-database.drizzle.ts.tpl

@@ -0,0 +1,146 @@
+import { PGlite } from '@electric-sql/pglite';
+import { is, sql, SQL } from 'drizzle-orm';
+import { getTableConfig, PgDialect, PgTable } from 'drizzle-orm/pg-core';
+import { drizzle } from 'drizzle-orm/pglite';
+import { connectToDatabase } from '{{alias.platform}}/database/connect-to-database.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+{{#if audit.on}}
+import { auditGuardStatements } from '@ddd-ts-kit/audit/drizzle';
+{{/if}}
+import * as schema from '{{alias.platform}}/database/schema.js';
+
+export interface TestDatabase {
+  readonly persistence: Persistence;
+
+  /** Empties every table{{#if audit.on}} but the audit trail, which is append-only whoever asks{{/if}}: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/**
+ * PostgreSQL in process (PGlite) by default, with the tables of ./schema.ts created from their
+ * Drizzle definitions: adapter and end-to-end specs need no container and no migration run.
+ * With a URL, the tests run on that server instead, which must already be migrated
+ * (`npm run db:migrate`); the migrations remain what production applies.
+ */
+export function openTestDatabase(url?: string): Promise<TestDatabase> {
+  return url === undefined ? openInProcess() : openServer(url);
+}
+
+async function openInProcess(): Promise<TestDatabase> {
+  const client = new PGlite();
+
+{{#if audit.on}}
+  for (const statement of [...tables().flatMap(createStatements), ...auditGuardStatements(schema.AUDIT_SCHEMA)]) {
+    await client.exec(statement);
+  }
+{{/if}}
+{{#unless audit.on}}
+  for (const statement of tables().flatMap(createStatements)) {
+    await client.exec(statement);
+  }
+{{/unless}}
+
+  return {
+    persistence: persistenceOver(drizzle(client), () => client.close()),
+    reset: async () => {
+      await client.exec(truncateStatement());
+    },
+    close: () => client.close(),
+  };
+}
+
+async function openServer(url: string): Promise<TestDatabase> {
+  const connection = connectToDatabase(url);
+
+  return {
+    persistence: persistenceOver(connection.db, () => connection.close()),
+    reset: async () => {
+      await connection.db.execute(sql.raw(truncateStatement()));
+    },
+    close: () => connection.close(),
+  };
+}
+
+function tables(): PgTable[] {
+  const exported: readonly unknown[] = Object.values(schema);
+
+  return exported.filter((value): value is PgTable => is(value, PgTable));
+}
+
+{{#if audit.on}}
+function truncateStatement(): string {
+  const emptied = tables().filter((table) => getTableConfig(table).schema !== schema.AUDIT_SCHEMA);
+
+  return 'truncate table ' + emptied.map(qualifiedName).join(', ') + ' restart identity';
+}
+{{/if}}
+{{#unless audit.on}}
+function truncateStatement(): string {
+  return 'truncate table ' + tables().map(qualifiedName).join(', ') + ' restart identity';
+}
+{{/unless}}
+
+function qualifiedName(table: PgTable): string {
+  const { schema: owner, name } = getTableConfig(table);
+
+  return owner === undefined ? quote(name) : quote(owner) + '.' + quote(name);
+}
+
+function createStatements(table: PgTable): string[] {
+  const { schema: owner, columns, primaryKeys } = getTableConfig(table);
+
+  const keys = primaryKeys.map(
+    (key) => 'primary key (' + key.columns.map((column) => quote(column.name)).join(', ') + ')',
+  );
+
+  const body = [...columns.map(columnDefinition), ...keys].join(', ');
+
+  return [
+    ...(owner === undefined ? [] : ['create schema if not exists ' + quote(owner)]),
+    'create table if not exists ' + qualifiedName(table) + ' (' + body + ')',
+  ];
+}
+
+type Column = ReturnType<typeof getTableConfig>['columns'][number];
+
+function columnDefinition(column: Column): string {
+  const identity = column.generatedIdentity === undefined ? '' : ' generated always as identity';
+
+  return [
+    quote(column.name) + ' ' + column.getSQLType() + identity,
+    column.notNull ? ' not null' : '',
+    defaultClause(column),
+    column.primary ? ' primary key' : '',
+  ].join('');
+}
+
+const dialect = new PgDialect();
+
+function defaultClause(column: Column): string {
+  const value: unknown = column.default;
+
+  if (!column.hasDefault || value === undefined) {
+    return '';
+  }
+
+  if (is(value, SQL)) {
+    return ' default ' + dialect.sqlToQuery(value.inlineParams()).sql;
+  }
+
+  // A text or a JSON document is a quoted literal; a number or a boolean is written as it is.
+  return (
+    ' default ' +
+    (typeof value === 'string'
+      ? "'" + value + "'"
+      : typeof value === 'object'
+        ? "'" + JSON.stringify(value) + "'"
+        : JSON.stringify(value))
+  );
+}
+
+function quote(name: string): string {
+  return '"' + name + '"';
+}

package/templates/init/platform/database/open-test-database.knex.ts.tpl

@@ -0,0 +1,83 @@
+import { PGlite } from '@electric-sql/pglite';
+import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
+import type { Knex } from 'knex';
+import { connectToDatabase } from '{{alias.platform}}/database/connect-to-database.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+{{#if audit.on}}
+import { AUDIT_SCHEMA, createTables } from '{{alias.platform}}/database/schema.js';
+{{/if}}
+{{#unless audit.on}}
+import { createTables } from '{{alias.platform}}/database/schema.js';
+{{/unless}}
+
+export interface TestDatabase {
+  readonly persistence: Persistence;
+
+  /** Empties every table{{#if audit.on}} but the audit trail, which is append-only whoever asks{{/if}}: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/**
+ * PostgreSQL in process (PGlite, served over the wire protocol) by default, with the tables of
+ * ./schema.ts: adapter and end-to-end specs need no container. With a URL, the tests run on
+ * that server instead, which must already be migrated (`npm run db:migrate`).
+ */
+export function openTestDatabase(url?: string): Promise<TestDatabase> {
+  return url === undefined ? openInProcess() : openServer(url);
+}
+
+async function openInProcess(): Promise<TestDatabase> {
+  const engine = await PGlite.create();
+  const server = new PGLiteSocketServer({ db: engine, host: '127.0.0.1', port: 0, maxConnections: 10 });
+
+  await server.start();
+
+  // PGlite is one session behind every socket: a second connection would step into the transaction of the first.
+  const connection = connectToDatabase('postgresql://postgres:postgres@' + server.getServerConn() + '/postgres', {
+    poolSize: 1,
+  });
+
+  await createTables(connection.db);
+
+  const close = async (): Promise<void> => {
+    await connection.close();
+    await server.stop();
+    await engine.close();
+  };
+
+  return { persistence: persistenceOver(connection.db, close), reset: () => truncateAll(connection.db), close };
+}
+
+async function openServer(url: string): Promise<TestDatabase> {
+  const connection = connectToDatabase(url);
+
+  return {
+    persistence: persistenceOver(connection.db, () => connection.close()),
+    reset: () => truncateAll(connection.db),
+    close: () => connection.close(),
+  };
+}
+
+interface TableName {
+  readonly table_schema: string;
+  readonly table_name: string;
+}
+
+async function truncateAll(db: Knex): Promise<void> {
+  const tables = await db<TableName>('information_schema.tables')
+    .select('table_schema', 'table_name')
+    .where('table_type', 'BASE TABLE')
+    .whereNotIn('table_schema', ['pg_catalog', 'information_schema'{{#if audit.on}}, AUDIT_SCHEMA{{/if}}])
+    .whereNot('table_name', 'like', 'knex_migrations%');
+
+  if (tables.length === 0) {
+    return;
+  }
+
+  const names = tables.map((table) => '"' + table.table_schema + '"."' + table.table_name + '"').join(', ');
+
+  await db.raw('truncate table ' + names + ' restart identity');
+}

package/templates/init/platform/database/open-test-database.prisma.ts.tpl

@@ -0,0 +1,82 @@
+import { readFile } from 'node:fs/promises';
+import { PGlite } from '@electric-sql/pglite';
+import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
+import pg from 'pg';
+import type { PrismaClient } from '{{alias.generated}}/prisma/client.js';
+import { createClient } from '{{alias.platform}}/database/create-client.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+export interface TestDatabase {
+  readonly persistence: Persistence;
+
+  /** Empties every table: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/**
+ * PostgreSQL in process (PGlite, served over the wire protocol) by default, with the tables of
+ * generated/schema.sql, which `npm run db:client` derives from prisma/schema.prisma: adapter
+ * and end-to-end specs need no container. With a URL, the tests run on that server instead,
+ * which must already be migrated (`npm run db:migrate`).
+ */
+export function openTestDatabase(url?: string): Promise<TestDatabase> {
+  return url === undefined ? openInProcess() : openServer(url);
+}
+
+async function openInProcess(): Promise<TestDatabase> {
+  const engine = await PGlite.create();
+  const server = new PGLiteSocketServer({ db: engine, host: '127.0.0.1', port: 0, maxConnections: 10 });
+
+  await server.start();
+
+  const url = 'postgresql://postgres:postgres@' + server.getServerConn() + '/postgres';
+
+  await createTables(url);
+
+  // PGlite is one session behind every socket: a second connection would step into the transaction of the first.
+  const client = createClient(url, { poolSize: 1 });
+
+  const close = async (): Promise<void> => {
+    await client.$disconnect();
+    await server.stop();
+    await engine.close();
+  };
+
+  return { persistence: persistenceOver(client), reset: () => truncateAll(client), close };
+}
+
+async function openServer(url: string): Promise<TestDatabase> {
+  const client = createClient(url);
+
+  return { persistence: persistenceOver(client), reset: () => truncateAll(client), close: () => client.$disconnect() };
+}
+
+async function createTables(url: string): Promise<void> {
+  const connection = new pg.Client({ connectionString: url });
+
+  await connection.connect();
+  await connection.query(await readFile('generated/schema.sql', 'utf8'));
+  await connection.end();
+}
+
+interface TableName {
+  readonly table_schema: string;
+  readonly table_name: string;
+}
+
+async function truncateAll(client: PrismaClient): Promise<void> {
+  const tables = await client.$queryRaw<TableName[]>`
+    select table_schema, table_name from information_schema.tables
+    where table_type = 'BASE TABLE' and table_schema not in ('pg_catalog', 'information_schema') and table_name <> '_prisma_migrations'`;
+
+  if (tables.length === 0) {
+    return;
+  }
+
+  const names = tables.map((table) => '"' + table.table_schema + '"."' + table.table_name + '"').join(', ');
+
+  await client.$executeRawUnsafe('truncate table ' + names + ' restart identity');
+}

package/templates/init/platform/database/open-test-database.typeorm.ts.tpl

@@ -0,0 +1,78 @@
+import { PGlite } from '@electric-sql/pglite';
+import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
+import type { DataSource } from 'typeorm';
+import { createDataSource } from '{{alias.platform}}/database/create-data-source.js';
+import { persistenceOver } from '{{alias.platform}}/database/persistence-over.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+export interface TestDatabase {
+  readonly persistence: Persistence;
+
+  /** Empties every table: call it before each test. */
+  reset(): Promise<void>;
+
+  close(): Promise<void>;
+}
+
+/**
+ * PostgreSQL in process (PGlite, served over the wire protocol) by default, with the tables
+ * created from the entity schemas: adapter and end-to-end specs need no container. With a URL,
+ * the tests run on that server instead, which must already be migrated (`npm run db:migrate`).
+ */
+export function openTestDatabase(url?: string): Promise<TestDatabase> {
+  return url === undefined ? openInProcess() : openServer(url);
+}
+
+async function openInProcess(): Promise<TestDatabase> {
+  const engine = await PGlite.create();
+  const server = new PGLiteSocketServer({ db: engine, host: '127.0.0.1', port: 0, maxConnections: 10 });
+
+  await server.start();
+
+  // PGlite is one session behind every socket: a second connection would step into the transaction of the first.
+  const dataSource = createDataSource('postgresql://postgres:postgres@' + server.getServerConn() + '/postgres', {
+    poolSize: 1,
+  });
+
+  await dataSource.initialize();
+  await createTables(dataSource);
+
+  const persistence = persistenceOver(dataSource);
+
+  const close = async (): Promise<void> => {
+    await persistence.close();
+    await server.stop();
+    await engine.close();
+  };
+
+  return { persistence, reset: () => truncateAll(dataSource), close };
+}
+
+async function openServer(url: string): Promise<TestDatabase> {
+  const dataSource = createDataSource(url);
+
+  await dataSource.initialize();
+
+  const persistence = persistenceOver(dataSource);
+
+  return { persistence, reset: () => truncateAll(dataSource), close: () => persistence.close() };
+}
+
+// TypeORM creates tables, not schemas.
+async function createTables(dataSource: DataSource): Promise<void> {
+  for (const schema of new Set(dataSource.entityMetadatas.map((table) => table.schema))) {
+    if (schema !== undefined) {
+      await dataSource.query('create schema if not exists "' + schema + '"');
+    }
+  }
+
+  await dataSource.synchronize();
+}
+
+async function truncateAll(dataSource: DataSource): Promise<void> {
+  const names = dataSource.entityMetadatas.map(
+    (table) => (table.schema === undefined ? '' : '"' + table.schema + '".') + '"' + table.tableName + '"',
+  );
+
+  await dataSource.query('truncate table ' + names.join(', ') + ' restart identity');
+}

package/templates/init/platform/database/persistence-over.drizzle.ts.tpl

@@ -0,0 +1,17 @@
+import type { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
+import { createDrizzleUnitOfWork, DrizzleOutboxStore, DrizzleProcessedEventStore } from '@ddd-ts-kit/drizzle/postgres';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+import { outbox, processedEvents } from '{{alias.platform}}/database/schema.js';
+
+/** One object is the unit of work and what repositories query through; the stores write in its transaction. */
+export function persistenceOver(db: PgDatabase<PgQueryResultHKT>, close: () => Promise<void>): Persistence {
+  const unitOfWork = createDrizzleUnitOfWork(db);
+
+  return {
+    unitOfWork,
+    database: unitOfWork,
+    outbox: new DrizzleOutboxStore(unitOfWork, { table: outbox }),
+    processedEvents: new DrizzleProcessedEventStore(unitOfWork, { table: processedEvents }),
+    close,
+  };
+}

package/templates/init/platform/database/persistence-over.knex.ts.tpl

@@ -0,0 +1,17 @@
+import type { Knex } from 'knex';
+import { createKnexUnitOfWork, KnexOutboxStore, KnexProcessedEventStore } from '@ddd-ts-kit/knex';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+import { MESSAGING } from '{{alias.platform}}/database/schema.js';
+
+/** One object is the unit of work and what repositories query through; the stores write in its transaction. */
+export function persistenceOver(db: Knex, close: () => Promise<void>): Persistence {
+  const unitOfWork = createKnexUnitOfWork(db);
+
+  return {
+    unitOfWork,
+    database: unitOfWork,
+    outbox: new KnexOutboxStore(unitOfWork, { schema: MESSAGING }),
+    processedEvents: new KnexProcessedEventStore(unitOfWork, { schema: MESSAGING }),
+    close,
+  };
+}

package/templates/init/platform/database/persistence-over.prisma.ts.tpl

@@ -0,0 +1,20 @@
+import { createPrismaUnitOfWork, PrismaOutboxStore, PrismaProcessedEventStore } from '@ddd-ts-kit/prisma';
+import type { PrismaClient } from '{{alias.generated}}/prisma/client.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/** One object is the unit of work and what repositories query through; the stores are told how to reach their model. */
+export function persistenceOver(client: PrismaClient): Persistence {
+  const unitOfWork = createPrismaUnitOfWork(client);
+
+  return {
+    unitOfWork,
+    database: unitOfWork,
+    outbox: new PrismaOutboxStore(unitOfWork, {
+      delegate: (current) => current.outboxRecord,
+      // Prisma Client has no row locking: the claim is the one raw statement of the store.
+      claim: { strategy: 'skip-locked', dialect: 'postgresql', schema: 'messaging', raw: (current) => current },
+    }),
+    processedEvents: new PrismaProcessedEventStore(unitOfWork, { delegate: (current) => current.processedEvent }),
+    close: () => client.$disconnect(),
+  };
+}

package/templates/init/platform/database/persistence-over.typeorm.ts.tpl

@@ -0,0 +1,21 @@
+import type { DataSource } from 'typeorm';
+import { createTypeOrmUnitOfWork, TypeOrmOutboxStore, TypeOrmProcessedEventStore } from '@ddd-ts-kit/typeorm';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+import { outbox, processedEvents } from '{{alias.platform}}/database/schema.js';
+
+/** One object is the unit of work and what repositories query through; the stores write through its manager. */
+export function persistenceOver(dataSource: DataSource): Persistence {
+  const unitOfWork = createTypeOrmUnitOfWork(dataSource);
+
+  return {
+    unitOfWork,
+    database: unitOfWork,
+    outbox: new TypeOrmOutboxStore(unitOfWork, { entity: outbox }),
+    processedEvents: new TypeOrmProcessedEventStore(unitOfWork, { entity: processedEvents }),
+    close: async () => {
+      if (dataSource.isInitialized) {
+        await dataSource.destroy();
+      }
+    },
+  };
+}