schematic-pg 0.1.0

package/dist/db/db-client-generator.js

@@ -0,0 +1,70 @@
+import { PACKAGE_NAME } from '../constants.js';
+import { buildModelMetaSnapshot } from './model-meta.js';
+import { getClientExportName, TypeGenerator } from './type-generator.js';
+export class DbClientGenerator {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    generate() {
+        const imports = this.schema.models
+            .flatMap((model) => [
+            model.name,
+            `${model.name}CreateInput`,
+            `${model.name}UpdateInput`,
+            `${model.name}WhereInput`,
+            `${model.name}OrderByInput`,
+        ])
+            .join(',\n  ');
+        const clientEntries = this.schema.models.map((model) => this.generateClientEntry(model.name));
+        return [
+            '// Auto-generated by DbClientGenerator. Do not edit manually.',
+            "import type { Pool } from 'pg';",
+            `import { createModelClient } from '${PACKAGE_NAME}/db/model-client';`,
+            `import { hydrateModelMeta } from '${PACKAGE_NAME}/db/model-meta';`,
+            `import type {\n  ${imports},\n} from './db-types.js';`,
+            `import {\n  ${this.schema.models.map((model) => `${getClientExportName(model.name)}ModelMeta`).join(',\n  ')},\n} from './db-model-meta.js';`,
+            '',
+            'export function createDbClient(pool: Pool) {',
+            ...this.schema.models.map((model) => {
+                const clientKey = getClientExportName(model.name);
+                return `  const ${clientKey}Meta = hydrateModelMeta(${clientKey}ModelMeta);`;
+            }),
+            '',
+            '  return {',
+            clientEntries.map((entry) => `    ${entry},`).join('\n'),
+            '  };',
+            '}',
+            '',
+            'export type DbClient = ReturnType<typeof createDbClient>;',
+            '',
+        ].join('\n');
+    }
+    generateModelMetaModule() {
+        const blocks = this.schema.models.map((model) => {
+            const meta = buildModelMetaSnapshot(model, this.schema);
+            const clientKey = getClientExportName(model.name);
+            return `export const ${clientKey}ModelMeta = ${JSON.stringify(meta, null, 2)} as const;`;
+        });
+        return [
+            '// Auto-generated model metadata. Do not edit manually.',
+            `import type { ModelMetaSnapshot } from '${PACKAGE_NAME}/db/model-meta';`,
+            '',
+            ...blocks,
+            '',
+        ].join('\n');
+    }
+    generateClientEntry(modelName) {
+        const clientKey = getClientExportName(modelName);
+        return `${clientKey}: createModelClient<${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput, ${modelName}WhereInput, ${modelName}OrderByInput>(${clientKey}Meta, pool)`;
+    }
+}
+export function generateDbClientFiles(schema) {
+    const typeGenerator = new TypeGenerator(schema);
+    const dbClientGenerator = new DbClientGenerator(schema);
+    return {
+        dbTypes: typeGenerator.generate(),
+        dbClient: dbClientGenerator.generate(),
+        modelMeta: dbClientGenerator.generateModelMetaModule(),
+    };
+}

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

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

package/dist/db/diff-cli.js

@@ -0,0 +1,46 @@
+import { createMigration } from './migrations.js';
+import { defaultSchemaPath, generateSchemaDiff } from './diff.js';
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    let schemaPath = defaultSchemaPath();
+    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 = arg;
+        }
+    }
+    return { schemaPath, name, print };
+}
+async function main() {
+    const { schemaPath, name, print } = parseArgs(process.argv);
+    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`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Schema diff failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/db/diff.d.ts

@@ -0,0 +1,9 @@
+import type { Migration } from '../sql-generator/migration-types.js';
+export interface DiffResult {
+    migrations: Migration[];
+    sql: string;
+    hasDestructiveChanges: boolean;
+}
+export declare function generateSchemaDiff(schemaPath: string, cwd?: string): DiffResult;
+export declare function summarizeMigrations(migrations: Migration[]): Map<string, number>;
+export declare function defaultSchemaPath(cwd?: string): string;

package/dist/db/diff.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from '../schema-dsl/index.js';
+import { MigrationPlanner, MigrationSqlGenerator } from '../sql-generator/index.js';
+import { DESTRUCTIVE_MIGRATION_KINDS } from './migrations.js';
+import { readSnapshotSource } from './schema-state.js';
+export function generateSchemaDiff(schemaPath, cwd = process.cwd()) {
+    const snapshotSource = readSnapshotSource(cwd);
+    if (!snapshotSource) {
+        throw new Error(`No schema snapshot found at .schema-state/app.schema. Run db:bootstrap or copy app.schema to initialize the snapshot.`);
+    }
+    const oldSchema = parse(snapshotSource);
+    const newSource = readFileSync(schemaPath, 'utf8');
+    const newSchema = parse(newSource);
+    const planner = new MigrationPlanner();
+    const migrations = planner.generateMigration(oldSchema, newSchema);
+    const sql = new MigrationSqlGenerator().generate(migrations, newSchema);
+    const hasDestructiveChanges = migrations.some((migration) => DESTRUCTIVE_MIGRATION_KINDS.has(migration.kind));
+    return { migrations, sql, hasDestructiveChanges };
+}
+export function summarizeMigrations(migrations) {
+    const counts = new Map();
+    for (const migration of migrations) {
+        counts.set(migration.kind, (counts.get(migration.kind) ?? 0) + 1);
+    }
+    return counts;
+}
+export function defaultSchemaPath(cwd = process.cwd()) {
+    return join(cwd, 'app.schema');
+}

package/dist/db/errors.d.ts

@@ -0,0 +1,34 @@
+export declare class DatabaseError extends Error {
+    readonly code?: string;
+    readonly detail?: string;
+    readonly constraint?: string;
+    constructor(message: string, options?: {
+        code?: string;
+        detail?: string;
+        constraint?: string;
+        cause?: unknown;
+    });
+}
+export declare class UniqueConstraintError extends DatabaseError {
+    readonly fields: string[];
+    constructor(fields: string[], options?: {
+        constraint?: string;
+        detail?: string;
+        cause?: unknown;
+    });
+}
+export declare class ForeignKeyConstraintError extends DatabaseError {
+    readonly field?: string;
+    constructor(message: string, options?: {
+        field?: string;
+        constraint?: string;
+        detail?: string;
+        cause?: unknown;
+    });
+}
+export declare class NotFoundError extends DatabaseError {
+    readonly model: string;
+    readonly where: Record<string, unknown>;
+    constructor(model: string, where: Record<string, unknown>);
+}
+export declare function mapPgError(error: unknown, modelName: string, columnToField: Map<string, string>): DatabaseError;

package/dist/db/errors.js

@@ -0,0 +1,88 @@
+export class DatabaseError extends Error {
+    code;
+    detail;
+    constraint;
+    constructor(message, options) {
+        super(message, { cause: options?.cause });
+        this.name = 'DatabaseError';
+        this.code = options?.code;
+        this.detail = options?.detail;
+        this.constraint = options?.constraint;
+    }
+}
+export class UniqueConstraintError extends DatabaseError {
+    fields;
+    constructor(fields, options) {
+        super(`Unique constraint violation on ${fields.join(', ')}`, {
+            code: '23505',
+            constraint: options?.constraint,
+            detail: options?.detail,
+            cause: options?.cause,
+        });
+        this.name = 'UniqueConstraintError';
+        this.fields = fields;
+    }
+}
+export class ForeignKeyConstraintError extends DatabaseError {
+    field;
+    constructor(message, options) {
+        super(message, {
+            code: '23503',
+            constraint: options?.constraint,
+            detail: options?.detail,
+            cause: options?.cause,
+        });
+        this.name = 'ForeignKeyConstraintError';
+        this.field = options?.field;
+    }
+}
+export class NotFoundError extends DatabaseError {
+    model;
+    where;
+    constructor(model, where) {
+        super(`Record not found in ${model}`);
+        this.name = 'NotFoundError';
+        this.model = model;
+        this.where = where;
+    }
+}
+export function mapPgError(error, modelName, columnToField) {
+    if (!(error && typeof error === 'object' && 'code' in error)) {
+        return new DatabaseError(error instanceof Error ? error.message : String(error), { cause: error });
+    }
+    const pgError = error;
+    if (pgError.code === '23505') {
+        const fields = extractConstraintFields(pgError.detail, columnToField);
+        return new UniqueConstraintError(fields, {
+            constraint: pgError.constraint,
+            detail: pgError.detail,
+            cause: error,
+        });
+    }
+    if (pgError.code === '23503') {
+        return new ForeignKeyConstraintError(pgError.message ?? 'Foreign key constraint violation', {
+            constraint: pgError.constraint,
+            detail: pgError.detail,
+            cause: error,
+        });
+    }
+    return new DatabaseError(pgError.message ?? 'Database error', {
+        code: pgError.code,
+        detail: pgError.detail,
+        constraint: pgError.constraint,
+        cause: error,
+    });
+}
+function extractConstraintFields(detail, columnToField) {
+    if (!detail) {
+        return [];
+    }
+    const match = detail.match(/\(([^)]+)\)=\(/);
+    if (!match) {
+        return [];
+    }
+    return match[1]
+        .split(',')
+        .map((column) => column.trim())
+        .map((column) => columnToField.get(column) ?? column);
+}

package/dist/db/generate-client-cli.d.ts

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

package/dist/db/generate-client-cli.js

@@ -0,0 +1,21 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from '../schema-dsl/index.js';
+import { generateDbClientFiles } from './db-client-generator.js';
+const DEFAULT_SCHEMA_PATH = path.resolve('app.schema');
+const OUTPUT_DIR = path.resolve('generated');
+async function main() {
+    const schemaPath = process.argv[2] ?? DEFAULT_SCHEMA_PATH;
+    const source = await readFile(schemaPath, 'utf8');
+    const schema = parse(source);
+    const files = generateDbClientFiles(schema);
+    await mkdir(OUTPUT_DIR, { recursive: true });
+    await writeFile(path.join(OUTPUT_DIR, 'db-types.ts'), files.dbTypes, 'utf8');
+    await writeFile(path.join(OUTPUT_DIR, 'db-model-meta.ts'), files.modelMeta, 'utf8');
+    await writeFile(path.join(OUTPUT_DIR, 'db.ts'), files.dbClient, 'utf8');
+    console.log(`Generated db client files in ${OUTPUT_DIR}`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/db/index.d.ts

@@ -0,0 +1,19 @@
+export { bootstrapDatabase, generateBootstrapSql } from './bootstrap.js';
+export { DatabaseClient } from './client.js';
+export { getDatabaseUrl } from './config.js';
+export { QueryBuilder } from './query-builder.js';
+export { WhereTranslator } from './where-translator.js';
+export { createModelClient } from './model-client.js';
+export { TypeGenerator, generateDbTypes } from './type-generator.js';
+export { DbClientGenerator, generateDbClientFiles } from './db-client-generator.js';
+export { buildModelMeta, buildModelMetaSnapshot, hydrateModelMeta } from './model-meta.js';
+export { DatabaseError, UniqueConstraintError, ForeignKeyConstraintError, NotFoundError, mapPgError, } from './errors.js';
+export { mapRow, mapRows } from './row-mapper.js';
+export { toCamelCase, pluralize, toTableName, toColumnName, toClientKey } from './utils/naming.js';
+export { loadEnv, resetLoadEnvForTests } from './load-env.js';
+export { defaultSchemaPath, generateSchemaDiff, summarizeMigrations } from './diff.js';
+export type { DiffResult } from './diff.js';
+export { applyPendingMigrations } from './migrate.js';
+export { createMigration, ensureMigrationsDir, getMigrationsDir, listMigrationFiles, listPendingMigrations, readMigrationSql, DESTRUCTIVE_MIGRATION_KINDS, } from './migrations.js';
+export type { MigrationFile } from './migrations.js';
+export { ensureSnapshot, getSnapshotPath, readSnapshotSchema, readSnapshotSource, snapshotExists, writeSnapshot, } from './schema-state.js';

package/dist/db/index.js

@@ -0,0 +1,17 @@
+export { bootstrapDatabase, generateBootstrapSql } from './bootstrap.js';
+export { DatabaseClient } from './client.js';
+export { getDatabaseUrl } from './config.js';
+export { QueryBuilder } from './query-builder.js';
+export { WhereTranslator } from './where-translator.js';
+export { createModelClient } from './model-client.js';
+export { TypeGenerator, generateDbTypes } from './type-generator.js';
+export { DbClientGenerator, generateDbClientFiles } from './db-client-generator.js';
+export { buildModelMeta, buildModelMetaSnapshot, hydrateModelMeta } from './model-meta.js';
+export { DatabaseError, UniqueConstraintError, ForeignKeyConstraintError, NotFoundError, mapPgError, } from './errors.js';
+export { mapRow, mapRows } from './row-mapper.js';
+export { toCamelCase, pluralize, toTableName, toColumnName, toClientKey } from './utils/naming.js';
+export { loadEnv, resetLoadEnvForTests } from './load-env.js';
+export { defaultSchemaPath, generateSchemaDiff, summarizeMigrations } from './diff.js';
+export { applyPendingMigrations } from './migrate.js';
+export { createMigration, ensureMigrationsDir, getMigrationsDir, listMigrationFiles, listPendingMigrations, readMigrationSql, DESTRUCTIVE_MIGRATION_KINDS, } from './migrations.js';
+export { ensureSnapshot, getSnapshotPath, readSnapshotSchema, readSnapshotSource, snapshotExists, writeSnapshot, } from './schema-state.js';

package/dist/db/load-env.d.ts

@@ -0,0 +1,3 @@
+export declare function loadEnv(): void;
+export declare function resetLoadEnvForTests(): void;
+export declare function markEnvLoadedForTests(): void;

package/dist/db/load-env.js

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+let loaded = false;
+export function loadEnv() {
+    if (loaded) {
+        return;
+    }
+    const envPath = resolve(process.cwd(), '.env');
+    if (existsSync(envPath)) {
+        process.loadEnvFile(envPath);
+    }
+    loaded = true;
+}
+export function resetLoadEnvForTests() {
+    loaded = false;
+}
+export function markEnvLoadedForTests() {
+    loaded = true;
+}

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

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

package/dist/db/migrate-cli.js

@@ -0,0 +1,88 @@
+import { DatabaseClient } from './client.js';
+import { applyPendingMigrations } from './migrate.js';
+import { getAppliedMigrationFilenames, listMigrationFiles } from './migrations.js';
+import { defaultSchemaPath, generateSchemaDiff, summarizeMigrations } from './diff.js';
+import { snapshotExists } from './schema-state.js';
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const command = args[0] === 'status' ? 'status' : 'migrate';
+    const schemaArg = args.find((arg) => !arg.startsWith('--') && arg !== 'status');
+    const schemaPath = schemaArg ?? defaultSchemaPath();
+    return { command, schemaPath };
+}
+async function showStatus(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`);
+    }
+}
+async function runMigrate(schemaPath, client) {
+    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`);
+}
+async function main() {
+    const { command, schemaPath } = parseArgs(process.argv);
+    const client = new DatabaseClient();
+    try {
+        if (command === 'status') {
+            await showStatus(schemaPath, client);
+            return;
+        }
+        await runMigrate(schemaPath, client);
+    }
+    finally {
+        await client.close();
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Migration failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/db/migrate.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseClient } from './client.js';
+import { type MigrationFile } from './migrations.js';
+export declare function applyPendingMigrations(schemaPath?: string, client?: Pick<DatabaseClient, 'withClient'>, cwd?: string): Promise<MigrationFile[]>;

package/dist/db/migrate.js

@@ -0,0 +1,32 @@
+import { join } from 'node:path';
+import { DatabaseClient } from './client.js';
+import { listPendingMigrations, readMigrationSql, recordAppliedMigration, } from './migrations.js';
+import { writeSnapshot } from './schema-state.js';
+export async function applyPendingMigrations(schemaPath = join(process.cwd(), 'app.schema'), client = new DatabaseClient(), cwd = process.cwd()) {
+    const applied = [];
+    await client.withClient(async (pgClient) => {
+        const pending = await listPendingMigrations(pgClient, cwd);
+        if (pending.length === 0) {
+            return;
+        }
+        for (const migration of pending) {
+            await applyMigration(pgClient, migration);
+            applied.push(migration);
+        }
+        writeSnapshot(schemaPath, cwd);
+    });
+    return applied;
+}
+async function applyMigration(client, migration) {
+    const sql = readMigrationSql(migration);
+    await client.query('BEGIN');
+    try {
+        await client.query(sql);
+        await recordAppliedMigration(client, migration);
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        await client.query('ROLLBACK');
+        throw error;
+    }
+}

package/dist/db/migrations.d.ts

@@ -0,0 +1,17 @@
+import type { PoolClient } from 'pg';
+export interface MigrationFile {
+    id: number;
+    name: string;
+    filename: string;
+    path: string;
+}
+export declare function getMigrationsDir(cwd?: string): string;
+export declare function ensureMigrationsDir(cwd?: string): string;
+export declare function listMigrationFiles(cwd?: string): MigrationFile[];
+export declare function createMigration(name: string, sql: string, cwd?: string): MigrationFile;
+export declare function ensureMigrationsTable(client: PoolClient): Promise<void>;
+export declare function getAppliedMigrationFilenames(client: PoolClient): Promise<Set<string>>;
+export declare function listPendingMigrations(client: PoolClient, cwd?: string): Promise<MigrationFile[]>;
+export declare function recordAppliedMigration(client: PoolClient, migration: MigrationFile): Promise<void>;
+export declare function readMigrationSql(migration: MigrationFile): string;
+export declare const DESTRUCTIVE_MIGRATION_KINDS: Set<string>;

package/dist/db/migrations.js

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+const MIGRATIONS_DIR = 'migrations';
+const MIGRATIONS_TABLE = '_schema_migrations';
+export function getMigrationsDir(cwd = process.cwd()) {
+    return join(cwd, MIGRATIONS_DIR);
+}
+export function ensureMigrationsDir(cwd = process.cwd()) {
+    const dir = getMigrationsDir(cwd);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function listMigrationFiles(cwd = process.cwd()) {
+    const dir = getMigrationsDir(cwd);
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir)
+        .filter((filename) => filename.endsWith('.sql'))
+        .map((filename) => {
+        const match = /^(\d+)_(.+)\.sql$/.exec(filename);
+        if (!match) {
+            throw new Error(`Invalid migration filename: ${filename}`);
+        }
+        return {
+            id: Number(match[1]),
+            name: match[2],
+            filename,
+            path: join(dir, filename),
+        };
+    })
+        .sort((left, right) => left.id - right.id);
+}
+export function createMigration(name, sql, cwd = process.cwd()) {
+    const dir = ensureMigrationsDir(cwd);
+    const existing = listMigrationFiles(cwd);
+    const nextId = existing.length > 0 ? existing[existing.length - 1].id + 1 : 1;
+    const sanitizedName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const filename = `${String(nextId).padStart(4, '0')}_${sanitizedName}.sql`;
+    const path = join(dir, filename);
+    writeFileSync(path, sql, 'utf8');
+    return {
+        id: nextId,
+        name: sanitizedName,
+        filename,
+        path,
+    };
+}
+export async function ensureMigrationsTable(client) {
+    await client.query(`
+    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      filename TEXT NOT NULL UNIQUE,
+      applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    );
+  `);
+}
+export async function getAppliedMigrationFilenames(client) {
+    await ensureMigrationsTable(client);
+    const result = await client.query(`SELECT filename FROM ${MIGRATIONS_TABLE} ORDER BY id`);
+    return new Set(result.rows.map((row) => row.filename));
+}
+export async function listPendingMigrations(client, cwd = process.cwd()) {
+    const applied = await getAppliedMigrationFilenames(client);
+    return listMigrationFiles(cwd).filter((migration) => !applied.has(migration.filename));
+}
+export async function recordAppliedMigration(client, migration) {
+    await client.query(`INSERT INTO ${MIGRATIONS_TABLE} (id, name, filename) VALUES ($1, $2, $3)`, [migration.id, migration.name, migration.filename]);
+}
+export function readMigrationSql(migration) {
+    return readFileSync(migration.path, 'utf8');
+}
+export const DESTRUCTIVE_MIGRATION_KINDS = new Set([
+    'DropTable',
+    'DropColumn',
+    'DropConstraint',
+    'DropIndex',
+    'DropExtension',
+    'DropTrigger',
+]);

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

@@ -0,0 +1,36 @@
+import type { Pool } from 'pg';
+import type { ModelMeta } from './model-meta.js';
+export interface ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy> {
+    create(data: TCreate): Promise<T>;
+    findUnique(where: Record<string, unknown>): Promise<T | null>;
+    findFirst(args?: {
+        where?: TWhere;
+        orderBy?: TOrderBy;
+    }): Promise<T | null>;
+    findMany(args?: {
+        where?: TWhere;
+        orderBy?: TOrderBy | TOrderBy[];
+        take?: number;
+        skip?: number;
+    }): Promise<T[]>;
+    count(args?: {
+        where?: TWhere;
+    }): Promise<number>;
+    update(args: {
+        where: Record<string, unknown>;
+        data: TUpdate;
+    }): Promise<T>;
+    updateMany(args: {
+        where?: TWhere;
+        data: TUpdate;
+    }): Promise<{
+        count: number;
+    }>;
+    delete(where: Record<string, unknown>): Promise<T>;
+    deleteMany(args?: {
+        where?: TWhere;
+    }): Promise<{
+        count: number;
+    }>;
+}
+export declare function createModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>(model: ModelMeta, pool: Pool): ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>;