schematic-pg 0.1.0

package/dist/cli/db.js

@@ -0,0 +1,144 @@
+import { bootstrapDatabase } from '../db/bootstrap.js';
+import { DatabaseClient } from '../db/client.js';
+import { generateSchemaDiff, summarizeMigrations } from '../db/diff.js';
+import { applyPendingMigrations } from '../db/migrate.js';
+import { createMigration, getAppliedMigrationFilenames, listMigrationFiles } from '../db/migrations.js';
+import { snapshotExists } from '../db/schema-state.js';
+import { resolveSchemaPath } from './paths.js';
+function parseDiffArgs(args) {
+    let schemaPath = resolveSchemaPath();
+    let name;
+    let print = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === '--print') {
+            print = true;
+            continue;
+        }
+        if (arg === '--name') {
+            name = args[index + 1];
+            index++;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            schemaPath = resolveSchemaPath(arg);
+        }
+    }
+    return { schemaPath, name, print };
+}
+function parseMigrateArgs(args) {
+    const command = args[0] === 'status' ? 'status' : 'migrate';
+    const schemaArg = args.find((arg) => !arg.startsWith('--') && arg !== 'status');
+    const schemaPath = resolveSchemaPath(schemaArg);
+    return { command, schemaPath };
+}
+export async function runDbPing() {
+    const client = new DatabaseClient();
+    try {
+        const result = await client.query('SELECT 1 AS ok');
+        const ok = result.rows[0]?.ok;
+        if (ok !== 1) {
+            throw new Error(`Unexpected ping result: ${String(ok)}`);
+        }
+        process.stdout.write('Database connection OK (SELECT 1)\n');
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function runDbBootstrap(schemaPath) {
+    const resolvedSchemaPath = resolveSchemaPath(schemaPath);
+    const client = new DatabaseClient();
+    try {
+        await bootstrapDatabase(resolvedSchemaPath, client);
+        process.stdout.write(`Database bootstrapped from ${resolvedSchemaPath}\n`);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function runDbDiff(args) {
+    const { schemaPath, name, print } = parseDiffArgs(args);
+    const diff = generateSchemaDiff(schemaPath);
+    if (diff.migrations.length === 0) {
+        process.stdout.write('No schema changes detected.\n');
+        return;
+    }
+    if (diff.hasDestructiveChanges) {
+        process.stderr.write('Warning: migration includes destructive changes (drops).\n');
+    }
+    if (print || !name) {
+        process.stdout.write(diff.sql);
+        return;
+    }
+    const migration = createMigration(name, diff.sql);
+    process.stdout.write(`Migration written to ${migration.path}\n`);
+}
+async function showMigrationStatus(schemaPath, client) {
+    if (!snapshotExists()) {
+        process.stdout.write('Snapshot: missing (.schema-state/app.schema)\n');
+        process.stdout.write('\nPending schema changes (snapshot vs app.schema):\n');
+        process.stdout.write('  (snapshot not initialized — run db:bootstrap first)\n');
+    }
+    else {
+        process.stdout.write('Snapshot: present\n');
+        try {
+            const diff = generateSchemaDiff(schemaPath);
+            const counts = summarizeMigrations(diff.migrations);
+            process.stdout.write('\nPending schema changes (snapshot vs app.schema):\n');
+            if (counts.size === 0) {
+                process.stdout.write('  (none)\n');
+            }
+            else {
+                for (const [kind, count] of [...counts.entries()].sort()) {
+                    process.stdout.write(`  ${kind}: ${count}\n`);
+                }
+                if (diff.hasDestructiveChanges) {
+                    process.stdout.write('  Warning: includes destructive changes\n');
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stdout.write(`\nPending schema changes: error — ${message}\n`);
+        }
+    }
+    const applied = await client.withClient(async (pgClient) => getAppliedMigrationFilenames(pgClient));
+    const files = listMigrationFiles();
+    const pendingFiles = files.filter((migration) => !applied.has(migration.filename));
+    process.stdout.write('\nMigration files:\n');
+    if (files.length === 0) {
+        process.stdout.write('  (none)\n');
+    }
+    else {
+        for (const migration of files) {
+            const state = applied.has(migration.filename) ? 'applied' : 'pending';
+            process.stdout.write(`  [${state}] ${migration.filename}\n`);
+        }
+    }
+    if (pendingFiles.length > 0) {
+        process.stdout.write(`\n${pendingFiles.length} migration file(s) pending apply.\n`);
+    }
+}
+export async function runDbMigrate(args) {
+    const { command, schemaPath } = parseMigrateArgs(args);
+    const client = new DatabaseClient();
+    try {
+        if (command === 'status') {
+            await showMigrationStatus(schemaPath, client);
+            return;
+        }
+        const applied = await applyPendingMigrations(schemaPath, client);
+        if (applied.length === 0) {
+            process.stdout.write('No pending migrations to apply.\n');
+            return;
+        }
+        for (const migration of applied) {
+            process.stdout.write(`Applied ${migration.filename}\n`);
+        }
+        process.stdout.write(`Snapshot updated from ${schemaPath}\n`);
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function runDev(schemaPath?: string): Promise<void>;

package/dist/cli/dev.js

@@ -0,0 +1,10 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { generateApi, generateClient } from './generate.js';
+import { DEFAULT_OUTPUT_DIR } from './paths.js';
+export async function runDev(schemaPath) {
+    await generateClient(schemaPath);
+    await generateApi(schemaPath);
+    const appPath = path.resolve(DEFAULT_OUTPUT_DIR, 'app.ts');
+    execFileSync(process.execPath, ['--import', 'tsx', appPath], { stdio: 'inherit', cwd: process.cwd() });
+}

package/dist/cli/generate.d.ts

@@ -0,0 +1,4 @@
+export declare function generateSql(schemaPath?: string): Promise<string>;
+export declare function generateClient(schemaPath?: string): Promise<void>;
+export declare function generateApi(schemaPath?: string): Promise<void>;
+export declare function generateAll(schemaPath?: string): Promise<void>;

package/dist/cli/generate.js

@@ -0,0 +1,50 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from '../schema-dsl/index.js';
+import { generateApiFiles } from '../api-generator/index.js';
+import { generateDbClientFiles } from '../db/db-client-generator.js';
+import { SqlGenerator } from '../sql-generator/sql-generator.js';
+import { DEFAULT_CUSTOM_ROUTES_DIR, DEFAULT_OUTPUT_DIR, resolveSchemaPath, } from './paths.js';
+export async function generateSql(schemaPath) {
+    const resolvedSchemaPath = resolveSchemaPath(schemaPath);
+    const source = await readFile(resolvedSchemaPath, 'utf8');
+    return new SqlGenerator().generateFromSource(source);
+}
+export async function generateClient(schemaPath) {
+    const resolvedSchemaPath = resolveSchemaPath(schemaPath);
+    const outputDir = path.resolve(DEFAULT_OUTPUT_DIR);
+    const source = await readFile(resolvedSchemaPath, 'utf8');
+    const schema = parse(source);
+    const files = generateDbClientFiles(schema);
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(path.join(outputDir, 'db-types.ts'), files.dbTypes, 'utf8');
+    await writeFile(path.join(outputDir, 'db-model-meta.ts'), files.modelMeta, 'utf8');
+    await writeFile(path.join(outputDir, 'db.ts'), files.dbClient, 'utf8');
+    console.log(`Generated db client files in ${outputDir}`);
+}
+export async function generateApi(schemaPath) {
+    const resolvedSchemaPath = resolveSchemaPath(schemaPath);
+    const outputDir = path.resolve(DEFAULT_OUTPUT_DIR);
+    const routesDir = path.join(outputDir, 'routes');
+    const schemasDir = path.join(outputDir, 'schemas');
+    const source = await readFile(resolvedSchemaPath, 'utf8');
+    const schema = parse(source);
+    const files = generateApiFiles(schema, { customRoutesDir: DEFAULT_CUSTOM_ROUTES_DIR });
+    await mkdir(routesDir, { recursive: true });
+    await mkdir(schemasDir, { recursive: true });
+    await writeFile(path.join(outputDir, 'app.ts'), files.app, 'utf8');
+    await writeFile(path.join(outputDir, 'policies.ts'), files.policies, 'utf8');
+    await writeFile(path.join(schemasDir, 'validation.ts'), files.validation, 'utf8');
+    for (const [fileName, content] of files.routes) {
+        await writeFile(path.join(routesDir, fileName), content, 'utf8');
+    }
+    console.log(`Generated API files in ${outputDir}`);
+}
+export async function generateAll(schemaPath) {
+    const resolvedSchemaPath = resolveSchemaPath(schemaPath);
+    const sql = await generateSql(resolvedSchemaPath);
+    await writeFile(path.resolve('schema.sql'), sql, 'utf8');
+    console.log('Generated schema.sql');
+    await generateClient(resolvedSchemaPath);
+    await generateApi(resolvedSchemaPath);
+}

package/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(args: string[]): Promise<void>;

package/dist/cli/init.js

@@ -0,0 +1,57 @@
+import { PACKAGE_NAME } from '../constants.js';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { APP_SCHEMA_TEMPLATE, createPackageJsonTemplate, DOCKER_COMPOSE_TEMPLATE, ENV_TEMPLATE, HEALTH_ROUTE_TEMPLATE, TSCONFIG_TEMPLATE, } from './templates.js';
+const INIT_FILES = [
+    { relativePath: 'app.schema', content: APP_SCHEMA_TEMPLATE },
+    { relativePath: '.env', content: ENV_TEMPLATE },
+    { relativePath: 'docker-compose.yml', content: DOCKER_COMPOSE_TEMPLATE },
+    { relativePath: 'tsconfig.json', content: TSCONFIG_TEMPLATE },
+    { relativePath: 'src/routes/health.ts', content: HEALTH_ROUTE_TEMPLATE },
+];
+function resolveTargetDir(args) {
+    const targetArg = args.find((arg) => !arg.startsWith('--'));
+    return path.resolve(targetArg ?? '.');
+}
+function resolveProjectName(targetDir) {
+    return path.basename(targetDir) || `${PACKAGE_NAME}-app`;
+}
+export async function runInit(args) {
+    const targetDir = resolveTargetDir(args);
+    const projectName = resolveProjectName(targetDir);
+    if (targetDir !== process.cwd() && existsSync(targetDir)) {
+        const entries = await readdir(targetDir);
+        if (entries.length > 0) {
+            throw new Error(`Target directory is not empty: ${targetDir}`);
+        }
+    }
+    await mkdir(targetDir, { recursive: true });
+    await mkdir(path.join(targetDir, 'src/routes'), { recursive: true });
+    for (const file of INIT_FILES) {
+        const filePath = path.join(targetDir, file.relativePath);
+        if (existsSync(filePath)) {
+            console.log(`Skipped existing file: ${file.relativePath}`);
+            continue;
+        }
+        await writeFile(filePath, file.content, 'utf8');
+        console.log(`Created ${file.relativePath}`);
+    }
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        await writeFile(packageJsonPath, `${createPackageJsonTemplate(projectName)}\n`, 'utf8');
+        console.log('Created package.json');
+    }
+    else {
+        console.log('Skipped existing file: package.json');
+    }
+    console.log('\nNext steps:');
+    if (targetDir !== process.cwd()) {
+        console.log(`  cd ${targetDir}`);
+    }
+    console.log('  npm install');
+    console.log('  docker compose up -d');
+    console.log(`  npx ${PACKAGE_NAME} generate`);
+    console.log(`  npx ${PACKAGE_NAME} db:bootstrap`);
+    console.log(`  npx ${PACKAGE_NAME} dev`);
+}

package/dist/cli/paths.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_SCHEMA_FILE = "app.schema";
+export declare const DEFAULT_OUTPUT_DIR = "generated";
+export declare const DEFAULT_CUSTOM_ROUTES_DIR: string;
+export declare function resolveSchemaPath(schemaArg?: string): string;
+export declare function resolveOutputDir(): string;

package/dist/cli/paths.js

@@ -0,0 +1,10 @@
+import path from 'node:path';
+export const DEFAULT_SCHEMA_FILE = 'app.schema';
+export const DEFAULT_OUTPUT_DIR = 'generated';
+export const DEFAULT_CUSTOM_ROUTES_DIR = path.resolve('src/routes');
+export function resolveSchemaPath(schemaArg) {
+    return path.resolve(schemaArg ?? DEFAULT_SCHEMA_FILE);
+}
+export function resolveOutputDir() {
+    return path.resolve(DEFAULT_OUTPUT_DIR);
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,6 @@
+export declare const APP_SCHEMA_TEMPLATE = "models {\n  model User {\n    id:        UUID        @id @default(gen_random_uuid())\n    email:     VARCHAR(255) @unique\n    name:      VARCHAR(150)\n    createdAt: TIMESTAMP   @default(now())\n  }\n}\n";
+export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\n";
+export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgis/postgis:16-3.4\n    container_name: schematic-pg-postgres\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
+export declare const TSCONFIG_TEMPLATE = "{\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"strict\": true,\n    \"esModuleInterop\": true,\n    \"skipLibCheck\": true,\n    \"outDir\": \"dist\",\n    \"rootDir\": \".\"\n  },\n  \"include\": [\"generated/**/*\", \"src/**/*\"]\n}\n";
+export declare const HEALTH_ROUTE_TEMPLATE = "import { Hono } from 'hono';\nimport type { AppEnv } from 'schematic-pg/api/types';\n\nconst router = new Hono<AppEnv>();\nrouter.get('/', (c) => c.json({ ok: true }));\nexport default router;\n";
+export declare function createPackageJsonTemplate(projectName: string): string;

package/dist/cli/templates.js

@@ -0,0 +1,85 @@
+import { PACKAGE_NAME } from '../constants.js';
+export const APP_SCHEMA_TEMPLATE = `models {
+  model User {
+    id:        UUID        @id @default(gen_random_uuid())
+    email:     VARCHAR(255) @unique
+    name:      VARCHAR(150)
+    createdAt: TIMESTAMP   @default(now())
+  }
+}
+`;
+export const ENV_TEMPLATE = `DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest
+JWT_SECRET=
+JWT_ROLE_CLAIM=role
+JWT_USER_ID_CLAIM=sub
+`;
+export const DOCKER_COMPOSE_TEMPLATE = `services:
+  postgres:
+    image: postgis/postgis:16-3.4
+    container_name: schematic-pg-postgres
+    restart: unless-stopped
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: postgrest
+      POSTGRES_PASSWORD: postgrest
+      POSTGRES_DB: postgrest
+    volumes:
+      - ./docker_data/postgres:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgrest -d postgrest"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+`;
+export const TSCONFIG_TEMPLATE = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["generated/**/*", "src/**/*"]
+}
+`;
+export const HEALTH_ROUTE_TEMPLATE = `import { Hono } from 'hono';
+import type { AppEnv } from '${PACKAGE_NAME}/api/types';
+
+const router = new Hono<AppEnv>();
+router.get('/', (c) => c.json({ ok: true }));
+export default router;
+`;
+export function createPackageJsonTemplate(projectName) {
+    return JSON.stringify({
+        name: projectName,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        imports: {
+            'generated/db.js': './generated/db.js',
+            'generated/policies.js': './generated/policies.js',
+        },
+        scripts: {
+            dev: `${PACKAGE_NAME} dev`,
+            generate: `${PACKAGE_NAME} generate`,
+            'db:bootstrap': `${PACKAGE_NAME} db:bootstrap`,
+            'db:migrate': `${PACKAGE_NAME} db:migrate`,
+        },
+        dependencies: {
+            '@hono/node-server': '^2.0.6',
+            '@hono/zod-validator': '^0.8.0',
+            hono: '^4.12.27',
+            pg: '^8.22.0',
+            [PACKAGE_NAME]: '^0.1.0',
+            zod: '^4.4.3',
+        },
+        devDependencies: {
+            '@types/node': '^22.15.21',
+            typescript: '^5.8.3',
+        },
+    }, null, 2);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { runDbBootstrap, runDbDiff, runDbMigrate, runDbPing } from './cli/db.js';
+import { runDev } from './cli/dev.js';
+import { generateAll, generateApi, generateClient, generateSql } from './cli/generate.js';
+import { runInit } from './cli/init.js';
+import { PACKAGE_NAME } from './constants.js';
+const USAGE = `Usage: ${PACKAGE_NAME} <command> [options]
+
+Commands:
+  init [dir]                 Scaffold a new project
+  generate [schema]          Generate schema.sql, db client, and API
+  generate:sql [schema]      Generate SQL DDL to stdout
+  generate:client [schema]   Generate db client files
+  generate:api [schema]      Generate API files
+  dev [schema]               Regenerate client + API and start server
+  db:ping                    Test database connection
+  db:bootstrap [schema]      Apply DDL and snapshot schema state
+  db:diff [schema]           Show schema diff (--name <name> to write migration)
+  db:migrate [schema]        Apply pending migrations
+  db:migrate:status [schema] Show migration status
+`;
+function getPositionalArgs(args) {
+    return args.filter((arg) => !arg.startsWith('--'));
+}
+async function main() {
+    const [command, ...args] = process.argv.slice(2);
+    if (!command || command === '--help' || command === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const positionalArgs = getPositionalArgs(args);
+    const schemaPath = positionalArgs[0];
+    try {
+        switch (command) {
+            case 'init':
+                await runInit(args);
+                break;
+            case 'generate':
+                await generateAll(schemaPath);
+                break;
+            case 'generate:sql': {
+                const sql = await generateSql(schemaPath);
+                process.stdout.write(sql);
+                break;
+            }
+            case 'generate:client':
+                await generateClient(schemaPath);
+                break;
+            case 'generate:api':
+                await generateApi(schemaPath);
+                break;
+            case 'dev':
+                await runDev(schemaPath);
+                break;
+            case 'db:ping':
+                await runDbPing();
+                break;
+            case 'db:bootstrap':
+                await runDbBootstrap(schemaPath);
+                break;
+            case 'db:diff':
+                await runDbDiff(args);
+                break;
+            case 'db:migrate':
+                await runDbMigrate(args);
+                break;
+            case 'db:migrate:status':
+                await runDbMigrate(['status', ...args]);
+                break;
+            default:
+                process.stderr.write(`Unknown command: ${command}\n\n${USAGE}`);
+                process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    }
+}
+main();

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_NAME = "schematic-pg";

package/dist/constants.js

@@ -0,0 +1 @@
+export const PACKAGE_NAME = 'schematic-pg';

package/dist/db/bootstrap-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/bootstrap-cli.js

@@ -0,0 +1,17 @@
+import { join } from 'node:path';
+import { bootstrapDatabase } from './bootstrap.js';
+import { DatabaseClient } from './client.js';
+const schemaPath = process.argv[2] ?? join(process.cwd(), 'app.schema');
+const client = new DatabaseClient();
+bootstrapDatabase(schemaPath, client)
+    .then(() => {
+    process.stdout.write(`Database bootstrapped from ${schemaPath}\n`);
+})
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Database bootstrap failed: ${message}\n`);
+    process.exitCode = 1;
+})
+    .finally(async () => {
+    await client.close();
+});

package/dist/db/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseClient } from './client.js';
+export declare function generateBootstrapSql(schemaPath: string): string;
+export declare function bootstrapDatabase(schemaPath?: string, client?: Pick<DatabaseClient, 'withClient'>): Promise<void>;

package/dist/db/bootstrap.js

@@ -0,0 +1,16 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SqlGenerator } from '../sql-generator/sql-generator.js';
+import { DatabaseClient } from './client.js';
+import { writeSnapshot } from './schema-state.js';
+export function generateBootstrapSql(schemaPath) {
+    const source = readFileSync(schemaPath, 'utf8');
+    return new SqlGenerator().generateFromSource(source);
+}
+export async function bootstrapDatabase(schemaPath = join(process.cwd(), 'app.schema'), client = new DatabaseClient()) {
+    const sql = generateBootstrapSql(schemaPath);
+    await client.withClient(async (pgClient) => {
+        await pgClient.query(sql);
+    });
+    writeSnapshot(schemaPath);
+}

package/dist/db/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/cli.js

@@ -0,0 +1,20 @@
+import { DatabaseClient } from './client.js';
+async function main() {
+    const client = new DatabaseClient();
+    try {
+        const result = await client.query('SELECT 1 AS ok');
+        const ok = result.rows[0]?.ok;
+        if (ok !== 1) {
+            throw new Error(`Unexpected ping result: ${String(ok)}`);
+        }
+        process.stdout.write('Database connection OK (SELECT 1)\n');
+    }
+    finally {
+        await client.close();
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Database connection failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/db/client.d.ts

@@ -0,0 +1,8 @@
+import { type PoolClient, type QueryResult, type QueryResultRow } from 'pg';
+export declare class DatabaseClient {
+    private readonly pool;
+    constructor(connectionString?: string);
+    query<T extends QueryResultRow>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    withClient<T>(fn: (client: PoolClient) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}

package/dist/db/client.js

@@ -0,0 +1,23 @@
+import { Pool } from 'pg';
+import { getDatabaseUrl } from './config.js';
+export class DatabaseClient {
+    pool;
+    constructor(connectionString = getDatabaseUrl()) {
+        this.pool = new Pool({ connectionString });
+    }
+    async query(sql, params = []) {
+        return this.pool.query(sql, params);
+    }
+    async withClient(fn) {
+        const client = await this.pool.connect();
+        try {
+            return await fn(client);
+        }
+        finally {
+            client.release();
+        }
+    }
+    async close() {
+        await this.pool.end();
+    }
+}

package/dist/db/config.d.ts

@@ -0,0 +1 @@
+export declare function getDatabaseUrl(): string;

package/dist/db/config.js

@@ -0,0 +1,10 @@
+import { loadEnv } from './load-env.js';
+const missingDatabaseUrlMessage = 'DATABASE_URL is not set. Copy .env.example to .env and configure your connection string.';
+export function getDatabaseUrl() {
+    loadEnv();
+    const databaseUrl = process.env.DATABASE_URL;
+    if (!databaseUrl) {
+        throw new Error(missingDatabaseUrlMessage);
+    }
+    return databaseUrl;
+}

package/dist/db/db-client-generator.d.ts

@@ -0,0 +1,13 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export declare class DbClientGenerator {
+    private readonly schema;
+    constructor(schema: Schema);
+    generate(): string;
+    generateModelMetaModule(): string;
+    private generateClientEntry;
+}
+export declare function generateDbClientFiles(schema: Schema): {
+    dbTypes: string;
+    dbClient: string;
+    modelMeta: string;
+};