@opengroundplan/core 0.1.1

package/templates/layers/db-postgres/files/src/db/postgres/database.ts

@@ -0,0 +1,109 @@
+/**
+ * db-core's Database port over node-postgres. One pool per process; each
+ * transaction takes a single client so every repository in that unit of work
+ * shares the same PostgreSQL transaction.
+ */
+import { Pool, type PoolClient } from 'pg';
+import type { Database, Entity, EntityId, Repository, UnitOfWork } from '../ports.js';
+import { DbError } from '../errors.js';
+import { toPoolConfig } from './config.js';
+import { toDbError } from './errors.js';
+import { PostgresRepository } from './repository.js';
+
+class PostgresUnitOfWork implements UnitOfWork {
+  private settled = false;
+
+  constructor(private readonly client: PoolClient) {}
+
+  repository<T extends Entity<TId>, TId extends EntityId = string>(
+    collection: string,
+  ): Repository<T, TId> {
+    this.assertOpen();
+    return new PostgresRepository<T, TId>(this.client, collection);
+  }
+
+  async commit(): Promise<void> {
+    this.assertOpen();
+    this.settled = true;
+    await this.client.query('COMMIT');
+  }
+
+  async rollback(): Promise<void> {
+    this.assertOpen();
+    this.settled = true;
+    await this.client.query('ROLLBACK');
+  }
+
+  /** Set by the owning transaction once it has settled the client itself. */
+  markSettled(): void {
+    this.settled = true;
+  }
+
+  get isSettled(): boolean {
+    return this.settled;
+  }
+
+  private assertOpen(): void {
+    if (this.settled) throw new DbError('unknown', 'This unit of work has already been settled.');
+  }
+}
+
+export class PostgresDatabase implements Database {
+  private pool: Pool | undefined;
+  private closed = false;
+
+  private get connections(): Pool {
+    if (this.closed) throw new DbError('unavailable', 'The database has been closed.');
+    if (!this.pool) {
+      this.pool = new Pool(toPoolConfig());
+      // Without a listener a dropped idle connection is an unhandled 'error'
+      // event, which takes the process down.
+      this.pool.on('error', (error) => console.error('[db] idle client error', error));
+    }
+    return this.pool;
+  }
+
+  async transaction<R>(work: (uow: UnitOfWork) => Promise<R>): Promise<R> {
+    const client = await this.connect();
+    const uow = new PostgresUnitOfWork(client);
+
+    try {
+      await client.query('BEGIN');
+      const result = await work(uow);
+      if (!uow.isSettled) await client.query('COMMIT');
+      uow.markSettled();
+      return result;
+    } catch (error) {
+      // Rollback is best effort: the connection may already be gone.
+      if (!uow.isSettled) await client.query('ROLLBACK').catch(() => undefined);
+      uow.markSettled();
+      throw toDbError(error);
+    } finally {
+      client.release();
+    }
+  }
+
+  async ping(): Promise<boolean> {
+    try {
+      await this.connections.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async close(): Promise<void> {
+    this.closed = true;
+    const pool = this.pool;
+    this.pool = undefined;
+    await pool?.end();
+  }
+
+  private async connect(): Promise<PoolClient> {
+    try {
+      return await this.connections.connect();
+    } catch (error) {
+      throw toDbError(error);
+    }
+  }
+}

package/templates/layers/db-postgres/files/src/db/postgres/errors.ts

@@ -0,0 +1,48 @@
+/**
+ * SQLSTATE translation. Drivers leak vendor codes; db-core's taxonomy is what
+ * callers branch on, so the mapping lives here and nowhere else.
+ *
+ * Codes: https://www.postgresql.org/docs/current/errcodes-appendix.html
+ */
+import { DbError, type DbErrorKind } from '../errors.js';
+
+const BY_CODE: Readonly<Record<string, DbErrorKind>> = {
+  '23505': 'conflict', // unique_violation
+  '23502': 'integrity', // not_null_violation
+  '23503': 'integrity', // foreign_key_violation
+  '23514': 'integrity', // check_violation
+  '23P01': 'integrity', // exclusion_violation
+  '40001': 'transient', // serialization_failure
+  '40P01': 'transient', // deadlock_detected
+  '55P03': 'transient', // lock_not_available
+  '57014': 'timeout', // query_canceled, which is what statement_timeout raises
+  '53300': 'unavailable', // too_many_connections
+  '57P01': 'unavailable', // admin_shutdown
+  '57P02': 'unavailable', // crash_shutdown
+  '57P03': 'unavailable', // cannot_connect_now
+};
+
+/** Whole classes that map uniformly, checked after the exact codes above. */
+const BY_CLASS: Readonly<Record<string, DbErrorKind>> = {
+  '08': 'unavailable', // connection exception
+  '53': 'unavailable', // insufficient resources
+  '23': 'integrity', // integrity constraint violation
+};
+
+function sqlState(error: unknown): string | undefined {
+  if (typeof error !== 'object' || error === null) return undefined;
+  const code = (error as { code?: unknown }).code;
+  return typeof code === 'string' ? code : undefined;
+}
+
+export function classify(error: unknown): DbErrorKind {
+  const state = sqlState(error);
+  if (!state) return 'unknown';
+  return BY_CODE[state] ?? BY_CLASS[state.slice(0, 2)] ?? 'unknown';
+}
+
+/** Wraps a driver error as a DbError, preserving the original as `detail`. */
+export function toDbError(error: unknown): DbError {
+  if (error instanceof DbError) return error;
+  return DbError.from(classify(error), error);
+}

package/templates/layers/db-postgres/files/src/db/postgres/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Installs PostgreSQL as the engine behind db-core's `database()`. Call once at
+ * startup, before anything resolves a repository.
+ */
+import { useDatabase } from '../index.js';
+import { PostgresDatabase } from './database.js';
+
+export { PostgresDatabase } from './database.js';
+export { PostgresRepository } from './repository.js';
+export { postgresConfig, toPoolConfig, type PostgresConfig, type SslMode } from './config.js';
+export { classify, toDbError } from './errors.js';
+export { runMigrations, pendingMigrations } from './migrate.js';
+
+export function usePostgres(): void {
+  useDatabase(() => new PostgresDatabase());
+}

package/templates/layers/db-postgres/files/src/db/postgres/migrate.cli.ts

@@ -0,0 +1,11 @@
+/** Entry point for `npm run db:migrate`. */
+import { runMigrations } from './migrate.js';
+
+runMigrations()
+  .then((applied) => {
+    console.log(applied.length ? `Applied ${applied.length}:\n  ${applied.join('\n  ')}` : 'Already up to date.');
+  })
+  .catch((error: unknown) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  });

package/templates/layers/db-postgres/files/src/db/postgres/migrate.ts

@@ -0,0 +1,134 @@
+/**
+ * Forward-only SQL migration runner.
+ *
+ * Files run in filename order, each in its own transaction, recorded with a
+ * checksum. An already-applied file that changed is a hard error: the database
+ * and the repository disagree about history, and guessing which one is right is
+ * how data gets lost.
+ */
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Client } from 'pg';
+import { dbConfig } from '../config.js';
+import { DbError } from '../errors.js';
+import { postgresConfig } from './config.js';
+import { toDbError } from './errors.js';
+
+/** Table names cannot be bound as parameters, so the value is validated instead. */
+const SAFE_IDENTIFIER = /^[a-z_][a-z0-9_]*$/;
+
+function migrationsTable(): string {
+  const table = postgresConfig.migrationsTable;
+  if (!SAFE_IDENTIFIER.test(table)) {
+    throw new DbError('unknown', `Migrations table must match ${SAFE_IDENTIFIER}, got "${table}"`);
+  }
+  return table;
+}
+
+async function listMigrations(): Promise<string[]> {
+  const directory = postgresConfig.migrationsDir;
+  const entries = await readdir(directory).catch((error: NodeJS.ErrnoException) => {
+    if (error.code === 'ENOENT') throw new DbError('unknown', `Migrations directory not found: ${directory}`);
+    throw error;
+  });
+  return entries.filter((name) => name.endsWith('.sql')).sort();
+}
+
+const checksum = (sql: string): string => createHash('sha256').update(sql, 'utf8').digest('hex');
+
+/**
+ * A dedicated Client, not a pooled one: the advisory lock lives on the session,
+ * and a pool could hand that session to someone else.
+ */
+async function withSession<R>(work: (client: Client) => Promise<R>): Promise<R> {
+  if (!dbConfig.url) throw new DbError('unknown', 'A database URL is required to run migrations.');
+
+  const client = new Client({ connectionString: dbConfig.url });
+  await client.connect();
+  try {
+    return await work(client);
+  } finally {
+    await client.end().catch(() => undefined);
+  }
+}
+
+/** Applies every pending migration and returns the filenames that ran. */
+export async function runMigrations(): Promise<string[]> {
+  const table = migrationsTable();
+  const files = await listMigrations();
+  const lockId = postgresConfig.migrationsLockId;
+
+  return withSession(async (client) => {
+    const applied: string[] = [];
+
+    // Request traffic runs under a statement_timeout; a migration may
+    // legitimately take far longer than that.
+    await client.query('SET statement_timeout = 0');
+    // Serialises concurrent deploys instead of letting them race.
+    await client.query('SELECT pg_advisory_lock($1)', [lockId]);
+
+    try {
+      await client.query(
+        `CREATE TABLE IF NOT EXISTS ${table} (
+           version    text PRIMARY KEY,
+           checksum   text NOT NULL,
+           applied_at timestamptz NOT NULL DEFAULT now()
+         )`,
+      );
+
+      const recorded = await client.query<{ version: string; checksum: string }>(
+        `SELECT version, checksum FROM ${table}`,
+      );
+      const known = new Map(recorded.rows.map((row) => [row.version, row.checksum]));
+
+      for (const file of files) {
+        const sql = await readFile(path.join(postgresConfig.migrationsDir, file), 'utf8');
+        const digest = checksum(sql);
+        const previous = known.get(file);
+
+        if (previous !== undefined) {
+          if (previous !== digest) {
+            throw new DbError(
+              'conflict',
+              `Migration ${file} was edited after it was applied. Add a new migration instead.`,
+            );
+          }
+          continue;
+        }
+
+        await client.query('BEGIN');
+        try {
+          await client.query(sql);
+          await client.query(`INSERT INTO ${table} (version, checksum) VALUES ($1, $2)`, [file, digest]);
+          await client.query('COMMIT');
+        } catch (error) {
+          await client.query('ROLLBACK').catch(() => undefined);
+          throw new DbError('unknown', `Migration ${file} failed: ${toDbError(error).message}`, error);
+        }
+
+        applied.push(file);
+      }
+    } finally {
+      await client.query('SELECT pg_advisory_unlock($1)', [lockId]).catch(() => undefined);
+    }
+
+    return applied;
+  });
+}
+
+/** Names of migrations that exist on disk but have not run yet. */
+export async function pendingMigrations(): Promise<string[]> {
+  const table = migrationsTable();
+  const files = await listMigrations();
+
+  return withSession(async (client) => {
+    const recorded = await client
+      .query<{ version: string }>(`SELECT version FROM ${table}`)
+      // The table does not exist until the first run, so everything is pending.
+      .catch(() => ({ rows: [] as { version: string }[] }));
+
+    const known = new Set(recorded.rows.map((row) => row.version));
+    return files.filter((file) => !known.has(file));
+  });
+}

package/templates/layers/db-postgres/files/src/db/postgres/repository.ts

@@ -0,0 +1,159 @@
+/**
+ * Criteria -> SQL. Collections map to tables and entity keys to columns, both
+ * of which arrive as runtime strings, so every identifier is quoted and every
+ * value is bound as a parameter. Nothing is concatenated into SQL.
+ */
+import type { PoolClient, QueryResult, QueryResultRow } from 'pg';
+import { DbError } from '../errors.js';
+import type { Criteria, Entity, EntityId, Page, Repository, Sort } from '../ports.js';
+import { toDbError } from './errors.js';
+
+const MAX_IDENTIFIER_BYTES = 63;
+
+/** Double-quoting makes a name inert; the length check matches PostgreSQL's own limit. */
+function ident(name: string): string {
+  if (name.length === 0 || name.length > MAX_IDENTIFIER_BYTES || name.includes('\0')) {
+    throw new DbError('unknown', `Invalid SQL identifier: "${name}"`);
+  }
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+interface Fragment {
+  text: string;
+  values: unknown[];
+}
+
+function whereClause(where: Record<string, unknown> | undefined, from = 0): Fragment {
+  const entries = Object.entries(where ?? {});
+  if (entries.length === 0) return { text: '', values: [] };
+
+  // Placeholders are numbered off `values`, not off the entry index: an IS NULL
+  // test binds nothing, so the two would drift apart.
+  const values: unknown[] = [];
+  const parts = entries.map(([column, value]) => {
+    // IS NULL, because `= NULL` is never true in SQL.
+    if (value === null || value === undefined) return `${ident(column)} IS NULL`;
+    values.push(value);
+    return `${ident(column)} = $${from + values.length}`;
+  });
+
+  return { text: ` WHERE ${parts.join(' AND ')}`, values };
+}
+
+function orderClause<T>(sort: Sort<T>[] | undefined): string {
+  if (!sort || sort.length === 0) return '';
+  const parts = sort.map((s) => `${ident(s.field)} ${s.direction === 'desc' ? 'DESC' : 'ASC'}`);
+  return ` ORDER BY ${parts.join(', ')}`;
+}
+
+export class PostgresRepository<T extends Entity<TId>, TId extends EntityId = string>
+  implements Repository<T, TId>
+{
+  constructor(
+    private readonly client: PoolClient,
+    private readonly collection: string,
+  ) {}
+
+  private get table(): string {
+    return ident(this.collection);
+  }
+
+  async findById(id: TId): Promise<T | null> {
+    const rows = await this.query(`SELECT * FROM ${this.table} WHERE "id" = $1 LIMIT 1`, [id]);
+    return rows[0] ?? null;
+  }
+
+  async find(criteria: Criteria<T> = {}): Promise<T[]> {
+    const where = whereClause(criteria.where);
+    const values = [...where.values];
+
+    let text = `SELECT * FROM ${this.table}${where.text}${orderClause(criteria.sort)}`;
+    if (criteria.limit !== undefined) {
+      values.push(criteria.limit);
+      text += ` LIMIT $${values.length}`;
+    }
+    if (criteria.offset !== undefined) {
+      values.push(criteria.offset);
+      text += ` OFFSET $${values.length}`;
+    }
+
+    return this.query(text, values);
+  }
+
+  async page(criteria: Criteria<T> = {}): Promise<Page<T>> {
+    // Sequential on purpose: both share one client inside the caller's transaction.
+    const items = await this.find(criteria);
+    const total = await this.count({ where: criteria.where });
+
+    return {
+      items,
+      total,
+      limit: criteria.limit ?? items.length,
+      offset: criteria.offset ?? 0,
+    };
+  }
+
+  async count(criteria: Pick<Criteria<T>, 'where'> = {}): Promise<number> {
+    const where = whereClause(criteria.where);
+    // ::text because count() returns bigint, which the driver hands back as a string anyway.
+    const result = await this.run<{ count: string }>(
+      `SELECT count(*)::text AS count FROM ${this.table}${where.text}`,
+      where.values,
+    );
+    return Number(result.rows[0]?.count ?? 0);
+  }
+
+  async add(entity: T): Promise<T> {
+    const columns = Object.keys(entity);
+    if (columns.length === 0) throw new DbError('unknown', `${this.collection}: cannot insert an empty entity`);
+
+    const placeholders = columns.map((_, index) => `$${index + 1}`);
+    const rows = await this.query(
+      `INSERT INTO ${this.table} (${columns.map(ident).join(', ')}) ` +
+        `VALUES (${placeholders.join(', ')}) RETURNING *`,
+      columns.map((column) => (entity as Record<string, unknown>)[column]),
+    );
+
+    const [inserted] = rows;
+    if (!inserted) throw new DbError('unknown', `${this.collection}: insert returned no row`);
+    return inserted;
+  }
+
+  async update(entity: T): Promise<T> {
+    const columns = Object.keys(entity).filter((column) => column !== 'id');
+    if (columns.length === 0) throw new DbError('unknown', `${this.collection}: update needs a field besides id`);
+
+    const assignments = columns.map((column, index) => `${ident(column)} = $${index + 1}`);
+    const rows = await this.query(
+      `UPDATE ${this.table} SET ${assignments.join(', ')} WHERE "id" = $${columns.length + 1} RETURNING *`,
+      [...columns.map((column) => (entity as Record<string, unknown>)[column]), entity.id],
+    );
+
+    const [updated] = rows;
+    if (!updated) throw DbError.notFound(this.collection, entity.id);
+    return updated;
+  }
+
+  async remove(id: TId): Promise<boolean> {
+    const result = await this.run(`DELETE FROM ${this.table} WHERE "id" = $1`, [id]);
+    return (result.rowCount ?? 0) > 0;
+  }
+
+  // Rows are shaped by the table, which the type system cannot see; the cast is
+  // the one place that gap is acknowledged.
+  private async query(text: string, values: unknown[]): Promise<T[]> {
+    const result = await this.run<T>(text, values);
+    return result.rows;
+  }
+
+  private async run<R extends QueryResultRow>(
+    text: string,
+    values: unknown[],
+  ): Promise<QueryResult<R>> {
+    try {
+      return await this.client.query<R>(text, values);
+    } catch (error) {
+      throw toDbError(error);
+    }
+  }
+}

package/templates/layers/db-sqlite/blueprint.yaml

@@ -0,0 +1,147 @@
+id: db-sqlite
+kind: layer
+name: SQLite
+description: Embedded SQLite persistence — connection, pragmas, plain-SQL migrations, health probe. For local, single-node, and small workloads.
+tags: [database, sqlite, persistence, embedded, local-first]
+
+# db-core owns the shared persistence contract; this layer only supplies the engine.
+requires: [db-core]
+# One database engine per repo — the connection settings and migration dialect cannot coexist.
+conflicts: [db-postgres, db-mongo]
+# Virtual capabilities other layers may key off (auth sessions, job queues, caching).
+provides: [db-engine, sql-database, embedded-database]
+
+variables:
+  - name: sqliteFile
+    prompt: SQLite database file (relative to the repo root)
+    type: string
+    default: data/app.db
+    required: true
+
+  - name: packageManager
+    prompt: Node package manager
+    type: select
+    default: pnpm
+    when: "stack == 'typescript' || stack == 'node'"
+    choices:
+      - { value: pnpm, label: pnpm }
+      - { value: npm, label: npm }
+      - { value: yarn, label: yarn }
+      - { value: bun, label: bun }
+
+  - name: pythonPackageManager
+    prompt: Python package manager
+    type: select
+    default: uv
+    when: "stack == 'python'"
+    choices:
+      - { value: uv, label: uv }
+      - { value: pip, label: pip }
+      - { value: poetry, label: poetry }
+
+  - name: dotnetTargetFramework
+    prompt: Target framework for the persistence project
+    type: string
+    default: net10.0
+    when: "stack == 'dotnet'"
+
+files:
+  # ── stack-agnostic ──────────────────────────────────────────────────────────
+  - from: files/migrations/*.sql
+    to: .
+  - from: files/.env.sqlite.example
+    to: .
+  - from: files/docs/db/sqlite.md
+    to: .
+  - from: files/.gitignore.sqlite
+    to: .
+
+  # ── typescript / node ───────────────────────────────────────────────────────
+  - from: files/src/db/sqlite/*.ts
+    to: .
+    when: "stack == 'typescript' || stack == 'node'"
+
+  # ── python ──────────────────────────────────────────────────────────────────
+  # A sqlite/ subpackage inside db-core's db package, so imports stay relative and the
+  # code ships inside the installed src/<solution> package — matching db-mongo.
+  - from: files/src/__solutionName.snake__/db/sqlite/*.py
+    to: .
+    when: "stack == 'python'"
+  - from: files/tests/test_db_sqlite.py
+    to: .
+    when: "stack == 'python'"
+
+  # ── go ──────────────────────────────────────────────────────────────────────
+  - from: files/internal/db/sqlite/*.go
+    to: .
+    when: "stack == 'go'"
+
+  # ── dotnet ──────────────────────────────────────────────────────────────────
+  # Self-contained class library so it compiles without knowing the base's project layout.
+  - from: files/src/__solutionName.dot__.Persistence.Sqlite/*
+    to: .
+    when: "stack == 'dotnet'"
+
+  # Code that imports a package the manifest never installs does not build (ADR 0005).
+  - from: files/package.json
+    to: .
+    onConflict: merge-json
+    when: "stack == 'typescript' || stack == 'node'"
+
+  # Declared, not fetched by a post-apply step: `go get` after generation leaves the
+  # first build missing the module (ADR 0005, spec 003).
+  - from: files/go.mod
+    to: .
+    onConflict: merge
+    when: "stack == 'go'"
+
+  # Declared, not installed by a post-apply step: a package added after generation is
+  # missing from the first install (ADR 0005, spec 003).
+  - from: files/pyproject.toml
+    to: .
+    onConflict: merge
+    when: "stack == 'python'"
+
+  # The solution is completed declaratively rather than by `dotnet sln add`, which runs
+  # after the first build and is skippable — a solution missing projects that exist on
+  # disk builds green while covering less than the repo contains (ADR 0005, spec 003).
+  - from: files/__solutionName.dot__.slnx
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+  # Central package management: versions live in Directory.Packages.props and projects
+  # reference without one. A bare Version= on a PackageReference fails restore (NU1008).
+  - from: files/Directory.Packages.props
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+postApply:
+  # Dependencies are installed rather than merged into package.json — the engine has no
+  # JSON-merge writer, so a layer must never own a file the base already writes.
+  - run: pnpm add better-sqlite3@12.11.1 && pnpm add -D @types/better-sqlite3@7.6.13
+    when: "(stack == 'typescript' || stack == 'node') && packageManager == 'pnpm'"
+    optional: true
+  - run: npm install better-sqlite3@12.11.1 && npm install -D @types/better-sqlite3@7.6.13
+    when: "(stack == 'typescript' || stack == 'node') && packageManager == 'npm'"
+    optional: true
+  - run: yarn add better-sqlite3@12.11.1 && yarn add -D @types/better-sqlite3@7.6.13
+    when: "(stack == 'typescript' || stack == 'node') && packageManager == 'yarn'"
+    optional: true
+  - run: bun add better-sqlite3@12.11.1 && bun add -d @types/better-sqlite3@7.6.13
+    when: "(stack == 'typescript' || stack == 'node') && packageManager == 'bun'"
+    optional: true
+
+  - run: uv add aiosqlite==0.22.1
+    when: "stack == 'python' && pythonPackageManager == 'uv'"
+    optional: true
+  - run: python -m pip install aiosqlite==0.22.1
+    when: "stack == 'python' && pythonPackageManager == 'pip'"
+    optional: true
+  - run: poetry add aiosqlite==0.22.1
+    when: "stack == 'python' && pythonPackageManager == 'poetry'"
+    optional: true
+
+
+  # Glob expands in the POSIX shell only; docs/db/sqlite.md carries the manual command.

package/templates/layers/db-sqlite/files/.env.sqlite.example

@@ -0,0 +1,20 @@
+# db-sqlite — append these to .env. Every key is optional; the settings module
+# holds the single typed default table, so an unset key is not an error.
+
+# Database file. Use :memory: for an ephemeral database (tests, CI).
+SQLITE_FILE={{ sqliteFile }}
+
+# How long a writer waits for a lock before raising SQLITE_BUSY.
+SQLITE_BUSY_TIMEOUT_MS=5000
+
+# WAL gives concurrent readers alongside one writer. Ignored for :memory:.
+SQLITE_JOURNAL_MODE=WAL
+
+# NORMAL is the durable-enough pairing for WAL; FULL costs an fsync per commit.
+SQLITE_SYNCHRONOUS=NORMAL
+
+# SQLite leaves foreign keys off per connection unless asked.
+SQLITE_FOREIGN_KEYS=true
+
+# Directory scanned for *.sql migrations.
+SQLITE_MIGRATIONS_DIR=migrations

package/templates/layers/db-sqlite/files/.gitignore.sqlite

@@ -0,0 +1,5 @@
+# db-sqlite — append to .gitignore. The database and its WAL sidecars are local state.
+*.db
+*.db-wal
+*.db-shm
+{{ sqliteFile }}

package/templates/layers/db-sqlite/files/Directory.Packages.props

@@ -0,0 +1,6 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.10" />
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.12" />
+  </ItemGroup>
+</Project>

package/templates/layers/db-sqlite/files/__solutionName.dot__.slnx

@@ -0,0 +1,5 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/{{ solutionName | dot }}.Persistence.Sqlite/{{ solutionName | dot }}.Persistence.Sqlite.csproj" />
+  </Folder>
+</Solution>