@podosoft/podokit 1.0.2 → 1.1.4

package/dist/templates/base/README.md

@@ -2,18 +2,22 @@
 
 Generated with [PodoKit](https://github.com/podosoft-dev/podokit).
 
-A minimal Bun 1.4 TypeScript workspace. Add the `fullstack` template when you
-need an Elysia API and SvelteKit web application.
+A minimal Bun 1.4 TypeScript workspace with placeholder API/web scripts. Choose
+`fullstack` or `todo` when creating a project that needs the working Elysia API,
+SvelteKit web app, database integration, or feature modules.
+
+For a simple working app, those templates support SQLite, memory cache/events,
+local files, and local jobs without external PostgreSQL, Redis, or S3 services.
+`base` is for building your own foundation; it does not include the provider
+consumers or module integration points. See
+[Getting Started](https://github.com/podosoft-dev/podokit/blob/main/docs/getting-started.md).
 
 ## Getting started
 
 ```bash
 {{packageManager}} install
-{{packageManager}} run dev
-```
-
-Copy the example environment file before running:
-
-```bash
 cp .env.example .env
 ```
+
+Implement the workspace scripts before running the application. The generated
+`dev` commands are placeholders and do not start services.

package/dist/templates/fullstack/AGENTS.md

@@ -8,26 +8,44 @@ Follow it so your changes match the project's conventions.
 
 A Bun 1.4 full-stack TypeScript monorepo ({{packageManager}} workspaces):
 
-- `apps/api` — **Elysia** backend (`{{projectName}}-api`), Bun.SQL + PostgreSQL, merged OpenAPI at `/api-docs`.
+- `apps/api` — **Elysia** backend (`{{projectName}}-api`), Bun.SQL + `{{databaseProvider}}`, merged OpenAPI at `/api-docs`.
 - `apps/web` — **SvelteKit** frontend (`{{projectName}}-web`), Tailwind v4 + shadcn-svelte + typesafe-i18n.
-- `infra/` — Docker Compose (PostgreSQL/Redis) and example k3s manifests.
+- `infra/` — provider-aware Docker Compose and example k3s manifests.
 - `.podokit/` — PodoKit generation metadata plus application-owned development and
   deployment profiles (see "PodoKit tooling" below).
 
 ## Setup & commands
 
+Inspect active infrastructure with `podo provider list`. New-project defaults
+are `database=postgres`, `cache=redis`, `object-storage=s3`, `events=redis`, and
+`jobs=bullmq`. A simple single-process app can instead use `sqlite`, `memory`
+cache/events, `local` files, and `local` jobs. Only the database has a creation
+flag (`--database`); apply other choices using
+`podo provider set <capability> <provider> --apply` before adding features.
+Provider selection does not migrate or delete existing data.
+
 ```bash
 {{packageManager}} install
 cp .env.example .env
-docker compose -f infra/docker/docker-compose.yml up -d   # PostgreSQL (+ Redis)
+{{apiRun}} migration:run
 {{rootRun}} dev        # api on http://localhost:5002, web on http://localhost:5001
 ```
 
+For PostgreSQL, start `docker compose -f infra/docker/docker-compose.yml up -d`
+before migrating. Add `--profile cache` for Redis; Silo uses the overlay from
+`object-storage-s3`. Skip external services entirely for the complete local
+combination. `podo dev watch` is a separate container workflow and requires
+Docker. SQLite and local files default to `./data/podokit.sqlite` and
+`./data/files` relative to the API working directory; migrations and runtime
+must use the same database path. Keep local providers at one API process.
+Merge added module settings from `.env.example` into an existing `.env`.
+
 - **Ports: web = 5001, api = 5002.** The web app reaches the API only through its
   SvelteKit server proxy (`/api/*`), never with a direct browser `fetch`.
 - Build: `{{rootRun}} build`  ·  Type-check/lint: `{{rootRun}} lint`  ·  Unit tests: `{{rootRun}} test`
 - Per workspace: `{{apiRun}} build` / `{{webRun}} build`.
-- DB migrations (TypeORM migration layer only): `{{apiRun}} migration:run`.
+- Application migrations (PostgreSQL or SQLite): `{{apiRun}} migration:run`.
+- When `auth` is installed, run `{{apiRun}} migrate:all` for Better Auth and application tables.
 - e2e (Playwright, ships in `tests/`): `{{rootRun}} test:e2e`.
 - Playwright officially runs on Node, so `bunx playwright` respects its Node
   shebang. Node LTS is a test-tool dependency only; API, web, worker, migrations,
@@ -74,9 +92,10 @@ Useful commands:
   exact API WebSocket allowlist; never use a prefix or wildcard for that allowlist.
 - `podo add <module>` — add a feature (auth, admin-dashboard, redis, bullmq, …). It wires itself into the app; run `podo add` with no argument to list modules.
 - `podo remove <module>` — un-apply a module (inverse of add; refuses if another module needs it, keeps files you edited).
+- `podo provider list` / `podo provider set <capability> <provider> [--apply]` — inspect or switch database, cache, object storage, events, and jobs. Set is dry-run by default and never migrates or deletes provider data. Local providers require one API process.
 - `podo status` / `podo diff` — see your local edits vs. what PodoKit generated.
 - `podo update` — pull in template/module improvements (3-way merges your edits; never touches owned files).
-- `podo deploy` — plan, apply, verify, or roll back an immutable release on Kubernetes or one Docker host. Tag `vX.Y.Z` to build and push the images (`.github/workflows/release.yml`; check its runner — GitHub-hosted minutes are free for public repositories only). Use `.agents/skills/podokit-deploy`.
+- `podo deploy` — plan, apply, verify, or roll back an immutable release on Kubernetes or one Docker host. Production API WebSocket paths belong in the deployment profile's exact `exposure.webSocketPaths` allowlist; Compose trusts forwarding headers only from `exposure.trustedProxyCidrs`. Tag `vX.Y.Z` to build and push the images (`.github/workflows/release.yml`; check its runner — GitHub-hosted minutes are free for public repositories only). Use `.agents/skills/podokit-deploy`.
 - `podo deploy sync` — copy local build output into a running Compose deployment and restart it, for iterating without a release. Not a release: no image is published and the next `apply` discards it. Use `.agents/skills/podokit-deploy-fast`.
 
 ## Commit conventions

package/dist/templates/fullstack/README.md

@@ -2,9 +2,47 @@
 
 Full-stack TypeScript starter generated with [PodoKit](https://github.com/podosoft-dev/podokit).
 
-- `apps/api` — Bun 1.4 + Elysia API: schema-validated env, `/health` + `/health/ready`, merged OpenAPI at `/api-docs`, a standard error envelope, and Bun.SQL + PostgreSQL. TypeORM is used only to execute migrations.
+- `apps/api` — Bun 1.4 + Elysia API: schema-validated env, `/health` + `/health/ready`, merged OpenAPI at `/api-docs`, a standard error envelope, and Bun.SQL with PostgreSQL or SQLite. TypeORM is used only for PostgreSQL migrations; SQLite has its own migration runner.
 - `apps/web` — SvelteKit app (TailwindCSS v4, shadcn-svelte, typesafe-i18n) that talks to the API through a server-side proxy.
-- `infra/` — Docker Compose (PostgreSQL, Redis) and k3s manifests.
+- `infra/` — Docker Compose references for external services and k3s manifests.
+
+## Infrastructure choices
+
+Inspect the current selections with `{{packageExecutor}} @podosoft/podokit provider list`.
+New projects use these defaults unless configured otherwise:
+
+| Capability | Default | Lightweight alternative |
+| --- | --- | --- |
+| Database | `postgres` | `sqlite` |
+| Cache | `redis` | `memory` |
+| Object storage | `s3` | `local` |
+| Events | `redis` | `memory` |
+| Jobs | `bullmq` | `local` |
+
+For a simple program, prototype, or desktop app, SQLite, memory cache/events,
+local files, and local jobs can run inside one API process without PostgreSQL,
+Redis, or S3 services. `create --database sqlite` selects only the database;
+choose the other providers after creation:
+
+```bash
+{{packageExecutor}} @podosoft/podokit provider set cache memory --apply
+{{packageExecutor}} @podosoft/podokit provider set object-storage local --apply
+{{packageExecutor}} @podosoft/podokit provider set events memory --apply
+{{packageExecutor}} @podosoft/podokit provider set jobs local --apply
+```
+
+Apply providers before adding features, then install dependencies and merge new
+`.env.example` entries into `.env`. These commands install implementation modules
+and configure them; they do not move or delete data. SQLite defaults to
+`./data/podokit.sqlite`, and local files to `LOCAL_STORAGE_PATH=./data/files`,
+relative to the API working directory. Memory cache/events are lost on restart;
+the database, files, and local job records persist. Use absolute paths and back
+up the database and files together for packaged or production apps.
+
+Use the host-process setup below to avoid Docker. The containerized loop still
+requires Docker. See the PodoKit
+[runtime provider guide](https://github.com/podosoft-dev/podokit/blob/main/docs/providers.md)
+for server settings, Silo/AWS S3 configuration, and provider switching.
 
 ## Getting started
 
@@ -40,7 +78,7 @@ Run lifecycle and container commands from a second terminal:
 ```
 
 `dev watch` reads `.podokit/manifest.json` and automatically activates `cache`,
-`storage`, and `queue` when installed modules require Redis, MinIO, or a worker.
+`storage`, and `queue` when installed modules require Redis, Silo, or a worker.
 `dev up` uses the same shared gateway and module profiles without keeping Compose
 Watch attached.
 You can still activate an additional Compose profile explicitly:
@@ -57,13 +95,27 @@ through Compose Watch, including Vite HMR on the same portless browser origin.
 
 ### Alternative: host processes
 
-Use this loop when you want only the web and API processes on the host:
+Use this loop for an app with SQLite and local providers, or when you want the
+web and API processes on the host. Prepare the project first:
+
+```bash
+{{packageManager}} install
+cp .env.example .env
+{{apiRun}} migration:run
+```
+
+For PostgreSQL, start `docker compose -f infra/docker/docker-compose.yml up -d`
+before migrating. Redis needs `--profile cache`; Silo needs the storage overlay
+added by `object-storage-s3`. Skip those services for the complete local setup.
+
+Run each service in a separate terminal from the project root:
 
 ```bash
-# start local PostgreSQL + Redis
-docker compose -f infra/docker/docker-compose.yml up -d
+{{apiRun}} dev # terminal 1
+```
 
-{{packageManager}} run dev
+```bash
+{{webRun}} dev # terminal 2
 ```
 
 - API: http://localhost:5002 — health at `/health`, docs at `/api-docs`
@@ -71,13 +123,18 @@ docker compose -f infra/docker/docker-compose.yml up -d
 
 ## Database & migrations
 
-The API uses Bun.SQL for request-time queries and TypeORM only as a migration
-runner. Add a numbered migration under `apps/api/src/migrations`, then run it:
+The API uses Bun.SQL with the selected PostgreSQL or SQLite database. TypeORM
+runs PostgreSQL migrations; SQLite uses the local migration runner. Add a
+numbered migration under `apps/api/src/migrations`, then run it:
 
 ```bash
 {{apiRun}} migration:run
 ```
 
+When `auth` is installed, use `{{apiRun}} migrate:all` to create or update both
+Better Auth and application tables. Set the module's required environment
+values before migrating.
+
 Want a worked example? Generate the `todo` template instead:
 `{{packageExecutor}} @podosoft/podokit create my-app --template todo`.
 
@@ -118,5 +175,12 @@ docker build --build-arg PODOKIT_BUILD_ORIGIN=https://example.com -f apps/web/Do
 
 For a Docker Compose deployment behind a trusted reverse proxy, set
 `PROTOCOL_HEADER=x-forwarded-proto` and `HOST_HEADER=x-forwarded-host` in the
-deployment profile runtime configuration. Never trust client-controlled forwarded
-headers on a directly exposed container.
+deployment profile runtime configuration and list the proxy's direct CIDR blocks in
+`exposure.trustedProxyCidrs`. Never trust client-controlled forwarded headers on a
+directly exposed container.
+
+If the production API exposes WebSocket endpoints, list their exact paths under
+`exposure.webSocketPaths` in the deployment profile. The Compose driver then keeps a
+single published port, sends only those paths to API, and sends all other traffic to
+web. The external TLS proxy continues to use the same single upstream. Keep
+`trustedProxyCidrs` empty unless that upstream is a known reverse proxy.

package/dist/templates/fullstack/apps/api/package.json

@@ -6,17 +6,18 @@
     "dev": "bun --watch src/main.ts",
     "build": "bun scripts/build.mjs",
     "start": "bun dist/main.js",
-    "lint": "bunx tsc -p tsconfig.json --noEmit",
+    "lint": "bunx --bun tsc -p tsconfig.json --noEmit",
     "test": "bun test src",
     "contract": "bun scripts/verify-api-contract.ts",
     "migrate:all": "bun dist/database/migrate.js",
     "typeorm": "bunx typeorm-ts-node-commonjs -d src/database/data-source.ts",
-    "migration:run": "bun run typeorm -- migration:run",
-    "migration:revert": "bun run typeorm -- migration:revert",
+    "migration:run": "bun src/database/migrate.ts",
+    "migration:revert": "bun src/database/migrate.ts --revert",
     "migration:generate": "bun run typeorm -- migration:generate"
   },
   "dependencies": {
     "@podosoft/podokit-contracts": "^0.4.0",
+    "@podosoft/podokit-runtime": "^0.2.0",
     "@elysia/cors": "^1.4.2",
     "@elysia/openapi": "^1.4.15",
     "dotenv": "^16.4.5",

package/dist/templates/fullstack/apps/api/src/config/env.validation.ts

@@ -5,6 +5,7 @@ const schema = z.object({
   NODE_ENV: z.string().default("development"),
   PORT: z.coerce.number().default(5002),
   CORS_ORIGIN: z.string().optional(),
+  DATABASE_URL: z.string().optional(),
   POSTGRES_HOST: z.string().default("localhost"),
   POSTGRES_PORT: z.coerce.number().default(5432),
   POSTGRES_USER: z.string().default("podokit"),

package/dist/templates/fullstack/apps/api/src/config/providers.ts

@@ -0,0 +1,9 @@
+import type { ProviderSelections } from "@podosoft/podokit-runtime";
+
+export const PROVIDERS = {
+  database: "{{databaseProvider}}",
+  cache: "{{cacheProvider}}",
+  "object-storage": "{{objectStorageProvider}}",
+  events: "{{eventsProvider}}",
+  jobs: "{{jobsProvider}}",
+} as const satisfies ProviderSelections;

package/dist/templates/fullstack/apps/api/src/core/services.ts

@@ -1,10 +1,14 @@
 import { Elysia } from "elysia";
 import pino, { type Logger } from "pino";
+import {
+  DATABASE as RUNTIME_DATABASE,
+  type ServiceKey,
+} from "@podosoft/podokit-runtime";
 import type { AppEnv } from "../config/env.validation";
 import { Database } from "../database/database";
 import { ReadinessService } from "../health/readiness.service";
 
-export type ServiceKey<T> = symbol & { readonly __service?: T };
+export type { ServiceKey } from "@podosoft/podokit-runtime";
 
 export class ServiceRegistry {
   private readonly values = new Map<symbol, unknown>();
@@ -142,7 +146,7 @@ export class OpenApiRegistry {
   }
 }
 
-export const DATABASE = Symbol("database") as ServiceKey<Database>;
+export const DATABASE = RUNTIME_DATABASE as ServiceKey<Database>;
 export const READINESS = Symbol("readiness") as ServiceKey<ReadinessService>;
 export const LOGGER = Symbol("logger") as ServiceKey<Logger>;
 export const ACCESS_POLICY = Symbol("access-policy") as ServiceKey<AccessPolicy>;
@@ -185,6 +189,7 @@ export function createCoreServices(env: AppEnv): ServiceRegistry {
   accessPolicy.register("*", "/api-docs-json", "public");
   accessPolicy.register("*", "/api-docs-elysia-json", "public");
   services.register(DATABASE, database, () => database.close());
+  services.onStart(() => database.connect());
   services.register(READINESS, readiness);
   services.register(LOGGER, logger);
   services.register(ACCESS_POLICY, accessPolicy);

package/dist/templates/fullstack/apps/api/src/database/data-source.ts

@@ -2,23 +2,45 @@ import "dotenv/config";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DataSource, type DataSourceOptions } from "typeorm";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+import { PROVIDERS } from "../config/providers";
+import { validateEnv } from "../config/env.validation";
+import { databaseUrl, sqliteDatabasePath } from "./database";
 
 const compiledMigrations = join(process.cwd(), "dist", "migrations");
 const migrations = existsSync(compiledMigrations)
   ? [join(compiledMigrations, "[0-9]*.js")]
   : [join(process.cwd(), "src", "migrations", "[0-9]*.ts")];
 
-export const dataSourceOptions: DataSourceOptions = {
-  type: "postgres",
-  host: process.env.POSTGRES_HOST ?? "localhost",
-  port: Number(process.env.POSTGRES_PORT ?? 5432),
-  username: process.env.POSTGRES_USER ?? "podokit",
-  password: process.env.POSTGRES_PASSWORD ?? "podokit",
-  database: process.env.POSTGRES_DB ?? "podokit",
+const commonOptions = {
   entities: [],
   migrations,
   synchronize: false,
 };
 
+const env = validateEnv(process.env);
+function databaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
+
+export const dataSourceOptions: DataSourceOptions = databaseProvider() === "sqlite"
+  ? {
+      type: "better-sqlite3",
+      database: sqliteDatabasePath(databaseUrl(env)),
+      enableWAL: true,
+      ...commonOptions,
+    }
+  : {
+      type: "postgres",
+      ...(process.env.DATABASE_URL ? { url: process.env.DATABASE_URL } : {}),
+      host: env.POSTGRES_HOST,
+      port: env.POSTGRES_PORT,
+      username: env.POSTGRES_USER,
+      password: env.POSTGRES_PASSWORD,
+      database: env.POSTGRES_DB,
+      ...commonOptions,
+    };
+
 // Used by the TypeORM CLI for migrations (see package.json scripts).
-export default new DataSource(dataSourceOptions);
+export const appDataSource = new DataSource(dataSourceOptions);
+export default appDataSource;

package/dist/templates/fullstack/apps/api/src/database/database.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import type { AppEnv } from "../config/env.validation";
+import { PROVIDERS } from "../config/providers";
+import { databaseUrl, sqliteDatabasePath } from "./database";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+
+const env: AppEnv = {
+  NODE_ENV: "test",
+  PORT: 5002,
+  POSTGRES_HOST: "localhost",
+  POSTGRES_PORT: 5432,
+  POSTGRES_USER: "podokit",
+  POSTGRES_PASSWORD: "podokit",
+  POSTGRES_DB: "podokit",
+};
+
+function databaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
+
+describe("database provider", () => {
+  it("uses DATABASE_URL as the canonical connection setting", () => {
+    const provider = databaseProvider();
+    const DATABASE_URL = provider === "sqlite"
+      ? "sqlite://:memory:"
+      : "postgres://podokit:podokit@localhost:5432/podokit";
+    expect(databaseUrl({ ...env, DATABASE_URL })).toBe(DATABASE_URL);
+  });
+
+  it("keeps the PostgreSQL fields as a fallback and creates a SQLite default", () => {
+    const url = databaseUrl(env);
+    const provider = databaseProvider();
+    if (provider === "sqlite") expect(url).toMatch(/^sqlite:\/\//);
+    else expect(url).toBe("postgres://podokit:podokit@localhost:5432/podokit");
+  });
+
+  it("rejects a connection URL for the other database dialect", () => {
+    const provider = databaseProvider();
+    const DATABASE_URL = provider === "sqlite"
+      ? "postgres://podokit:podokit@localhost:5432/podokit"
+      : "sqlite://:memory:";
+    expect(() => databaseUrl({ ...env, DATABASE_URL })).toThrow("DATABASE_URL must use");
+  });
+
+  it("creates the parent directory for an explicit SQLite database", () => {
+    const root = mkdtempSync(join(tmpdir(), "podokit-sqlite-"));
+    try {
+      const path = join(root, "nested", "app.sqlite");
+      expect(sqliteDatabasePath(`sqlite://${path}`)).toBe(path);
+      expect(existsSync(dirname(path))).toBe(true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/dist/templates/fullstack/apps/api/src/database/database.ts

@@ -1,22 +1,78 @@
 import { SQL } from "bun";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import type { AppEnv } from "../config/env.validation";
+import { PROVIDERS } from "../config/providers";
+
+function isSqliteUrl(url: string): boolean {
+  return url === ":memory:" || /^(?:sqlite|file):/.test(url);
+}
+
+function selectedDatabaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
 
 export function databaseUrl(env: AppEnv): string {
+  const provider = selectedDatabaseProvider();
+  if (env.DATABASE_URL) {
+    if (provider === "sqlite" && !isSqliteUrl(env.DATABASE_URL)) {
+      throw new Error("DATABASE_URL must use sqlite:, file:, or :memory: for the SQLite provider");
+    }
+    if (provider === "postgres" && isSqliteUrl(env.DATABASE_URL)) {
+      throw new Error("DATABASE_URL must use postgres: for the PostgreSQL provider");
+    }
+    return env.DATABASE_URL;
+  }
+  if (provider === "sqlite") {
+    const path = resolve("./data/podokit.sqlite");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    return `sqlite://${path}`;
+  }
   const username = encodeURIComponent(env.POSTGRES_USER);
   const password = encodeURIComponent(env.POSTGRES_PASSWORD);
   const database = encodeURIComponent(env.POSTGRES_DB);
   return `postgres://${username}:${password}@${env.POSTGRES_HOST}:${env.POSTGRES_PORT}/${database}`;
 }
 
+export function sqliteDatabasePath(url: string): string {
+  if (url === ":memory:" || url === "sqlite://:memory:") return ":memory:";
+  const path = url.startsWith("sqlite://")
+    ? url.slice("sqlite://".length)
+    : url.startsWith("file:")
+      ? decodeURIComponent(new URL(url).pathname)
+      : undefined;
+  if (!path) throw new Error("SQLite database URL must use sqlite:, file:, or :memory:");
+  mkdirSync(dirname(resolve(path)), { recursive: true, mode: 0o700 });
+  return path;
+}
+
 export class Database {
+  readonly provider: DatabaseProviderName = selectedDatabaseProvider();
   readonly sql: SQL;
+  private ready?: Promise<void>;
 
   constructor(env: AppEnv) {
-    this.sql = new SQL(databaseUrl(env), { max: 20 });
+    const url = databaseUrl(env);
+    this.sql = this.provider === "sqlite"
+      ? new SQL(url, { adapter: "sqlite", create: true, readwrite: true, strict: true })
+      : new SQL(url, { max: 20 });
+  }
+
+  connect(): Promise<void> {
+    this.ready ??= (async () => {
+      if (this.provider === "sqlite") {
+        await this.sql`PRAGMA journal_mode = WAL`;
+        await this.sql`PRAGMA foreign_keys = ON`;
+        await this.sql`PRAGMA busy_timeout = 5000`;
+      }
+      await this.sql`SELECT 1`;
+    })();
+    return this.ready;
   }
 
   async ping(): Promise<void> {
-    await this.sql`SELECT 1`;
+    await this.connect();
   }
 
   async close(): Promise<void> {

package/dist/templates/fullstack/apps/api/src/database/migrate.ts

@@ -1,9 +1,31 @@
-import dataSource from "./data-source";
+import { Database as SqliteDatabase } from "bun:sqlite";
+import type { DatabaseProviderName } from "@podosoft/podokit-runtime";
+import { validateEnv } from "../config/env.validation";
+import { PROVIDERS } from "../config/providers";
+import { databaseUrl, sqliteDatabasePath } from "./database";
+import { revertLatestSqliteMigration, runSqliteMigrations } from "./sqlite-migrator";
+
+function databaseProvider(): DatabaseProviderName {
+  return PROVIDERS.database;
+}
 
 async function migrate(): Promise<void> {
+  if (databaseProvider() === "sqlite") {
+    const env = validateEnv(process.env);
+    const database = new SqliteDatabase(sqliteDatabasePath(databaseUrl(env)), { create: true });
+    try {
+      if (process.argv.includes("--revert")) await revertLatestSqliteMigration(database);
+      else await runSqliteMigrations(database);
+    } finally {
+      database.close();
+    }
+    return;
+  }
+  const { appDataSource: dataSource } = await import("./data-source.js");
   await dataSource.initialize();
   try {
-    await dataSource.runMigrations({ transaction: "all" });
+    if (process.argv.includes("--revert")) await dataSource.undoLastMigration({ transaction: "all" });
+    else await dataSource.runMigrations({ transaction: "all" });
   } finally {
     await dataSource.destroy();
   }

package/dist/templates/fullstack/apps/api/src/database/sqlite-migrator.spec.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "bun:test";
+import { Database as SqliteDatabase } from "bun:sqlite";
+import type { MigrationInterface, QueryRunner } from "typeorm";
+import {
+  revertLatestSqliteMigration,
+  runSqliteMigrations,
+  type SqliteMigrationDefinition,
+} from "./sqlite-migrator";
+
+class CreateExample1000 implements MigrationInterface {
+  name = "CreateExample1000";
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query('CREATE TABLE "example" ("id" text PRIMARY KEY)');
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query('DROP TABLE "example"');
+  }
+}
+
+const definitions: readonly SqliteMigrationDefinition[] = [
+  { timestamp: 1_000, migration: new CreateExample1000() },
+];
+
+describe("SQLite migrator", () => {
+  it("runs each migration once and records it atomically", async () => {
+    const database = new SqliteDatabase(":memory:");
+    try {
+      await runSqliteMigrations(database, definitions);
+      await runSqliteMigrations(database, definitions);
+      expect(database.query<{ count: number }, []>('SELECT count(*) AS "count" FROM "migrations"').get()?.count).toBe(1);
+      expect(database.query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE name = 'example'").get()?.name).toBe("example");
+    } finally {
+      database.close();
+    }
+  });
+
+  it("reverts the latest applied migration", async () => {
+    const database = new SqliteDatabase(":memory:");
+    try {
+      await runSqliteMigrations(database, definitions);
+      await expect(revertLatestSqliteMigration(database, definitions)).resolves.toBe(true);
+      expect(database.query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE name = 'example'").get()).toBeNull();
+      await expect(revertLatestSqliteMigration(database, definitions)).resolves.toBe(false);
+    } finally {
+      database.close();
+    }
+  });
+});