@kequtech/tenon-orm 0.3.0 → 0.4.0

package/dist/check.js

@@ -0,0 +1,147 @@
+import { defaultCodecs } from '@kequtech/pgclear';
+import { compareContracts } from './check/contracts.js';
+import { librarySymbols, loadProject, location } from './check/project.js';
+import { SourceAnalysis } from './check/source.js';
+import { readStatementMetadata } from './inspection/catalog.js';
+import { withInspectionConnection } from './inspection/connection.js';
+import { queryDescription } from './inspection/result.js';
+import { plainObject } from './validation.js';
+function distinct(diagnostics) {
+    return [
+        ...new Map(diagnostics.map((diagnostic) => [JSON.stringify(diagnostic), diagnostic])).values(),
+    ];
+}
+/** Analyse authored source without importing the application, binding values or executing its SQL. */
+export async function checkQueries(options) {
+    for (const name of Object.keys(plainObject(options, 'Check options'))) {
+        if (!['connection', 'target', 'project', 'session', 'timeouts', 'codecs', 'readTypes'].includes(name))
+            throw new Error(`Unknown check option: ${name}`);
+    }
+    const project = loadProject(options);
+    const libraries = librarySymbols(project);
+    const diagnostics = [...project.diagnostics];
+    const queries = project.selected.flatMap((source) => new SourceAnalysis(project, libraries).discover(source));
+    const selected = project.line === undefined
+        ? queries
+        : queries.filter((query) => {
+            const source = query.getSourceFile();
+            const start = source.getLineAndCharacterOfPosition(query.getStart(source)).line + 1;
+            const end = source.getLineAndCharacterOfPosition(query.end).line + 1;
+            // Include a variable declaration's first line when the template starts on its next line.
+            const declarationStart = query.parent.getSourceFile() === source
+                ? source.getLineAndCharacterOfPosition(query.parent.getStart(source)).line + 1
+                : start;
+            return project.line >= Math.min(start, declarationStart) && project.line <= end;
+        });
+    if (!selected.length || (project.line !== undefined && selected.length > 1)) {
+        diagnostics.push({
+            file: project.selected[0]?.fileName ?? project.project,
+            line: project.line ?? 1,
+            column: 1,
+            kind: 'unchecked',
+            code: selected.length ? 'ambiguous-query-target' : 'no-query-sites',
+            message: selected.length
+                ? 'Several queries occupy this line. Put their SQL tags on distinct lines.'
+                : 'No recognized complete Tenon query was found at the selected target.',
+        });
+        return { project: project.project, ok: false, queries: [], diagnostics };
+    }
+    const recovered = selected.map((query) => {
+        const analysis = new SourceAnalysis(project, libraries);
+        const variants = analysis.recover(query);
+        return { query, variants, diagnostics: analysis.issues };
+    });
+    const reports = [];
+    const codecs = options.codecs ?? defaultCodecs;
+    const readTypes = { ...options.readTypes };
+    for (const oid of Object.keys(readTypes)) {
+        if (codecs.typescript(Number(oid)) !== undefined)
+            throw new Error(`readTypes may only supply an unresolved custom decoder representation (OID ${oid} already has a known representation).`);
+    }
+    const finish = () => {
+        const all = distinct([...diagnostics, ...reports.flatMap((report) => report.diagnostics)]);
+        return {
+            project: project.project,
+            ok: reports.length > 0 && !all.some((diagnostic) => diagnostic.kind !== 'unproven'),
+            queries: reports,
+            diagnostics: all,
+        };
+    };
+    if (!recovered.some(({ variants }) => variants.length)) {
+        for (const entry of recovered)
+            reports.push({
+                ...location(entry.query),
+                status: 'unchecked',
+                variants: 0,
+                diagnostics: distinct(entry.diagnostics),
+            });
+        return finish();
+    }
+    let context;
+    try {
+        context = await withInspectionConnection(options, async (session, context) => {
+            for (const entry of recovered) {
+                const findings = [...entry.diagnostics];
+                let described = 0;
+                for (const [index, variant] of entry.variants.entries()) {
+                    try {
+                        const metadata = await readStatementMetadata(session, {
+                            text: variant.text,
+                            parameterTypes: variant.parameterTypes,
+                        });
+                        const description = queryDescription(metadata, context, codecs);
+                        described++;
+                        findings.push(...compareContracts(project, entry.query, variant, description, readTypes).map((diagnostic) => variant.uncertainParameters.length && diagnostic.kind === 'mismatch'
+                            ? {
+                                ...diagnostic,
+                                kind: 'unproven',
+                                code: 'encoder-dependent-result-unproven',
+                                variant: index + 1,
+                                message: `${diagnostic.message} The actual encoder OID is unknown, so this inferred result cannot contradict the declared type.`,
+                            }
+                            : { ...diagnostic, variant: index + 1 }));
+                    }
+                    catch (error) {
+                        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+                        const sqlError = typeof code === 'string' && code.startsWith('42') && code !== '42501';
+                        const uncertain = sqlError &&
+                            variant.uncertainParameters.length > 0 &&
+                            !['42601', '42P01'].includes(String(code));
+                        findings.push({
+                            ...location(entry.query),
+                            kind: uncertain ? 'unproven' : sqlError ? 'mismatch' : 'unchecked',
+                            code: typeof code === 'string' ? code : 'describe-failed',
+                            variant: index + 1,
+                            message: `${error instanceof Error ? error.message : 'Describe failed.'}${uncertain ? ' The actual encoder OID is unknown; this inference failure does not disprove the declared contract.' : ''}`,
+                        });
+                    }
+                }
+                reports.push({
+                    ...location(entry.query),
+                    status: findings.some((finding) => finding.kind === 'unchecked')
+                        ? 'unchecked'
+                        : 'analysed',
+                    variants: described,
+                    diagnostics: distinct(findings),
+                });
+            }
+            return context;
+        });
+    }
+    catch (error) {
+        for (const entry of recovered.slice(reports.length))
+            reports.push({
+                ...location(entry.query),
+                status: 'unchecked',
+                variants: 0,
+                diagnostics: entry.diagnostics,
+            });
+        diagnostics.push({
+            ...location(selected[0]),
+            kind: 'unchecked',
+            code: 'inspection-failed',
+            message: error instanceof Error ? error.message : 'Inspection connection failed.',
+        });
+    }
+    return { ...finish(), ...(context ? { context } : {}) };
+}

package/dist/cli.js

@@ -3,7 +3,7 @@ import { parseArgs } from 'node:util';
 import { adoptBaseline, captureBaseline } from './baseline.js';
 import { generateDefinitions } from './generate.js';
 import { writeDefinitions } from './generation/output.js';
-import { describeFlags, runDescribe } from './inspection/cli.js';
+import { describeFlags, inspectionSettings, runDescribe } from './inspection/cli.js';
 import { migrate, migrationStatus, rollback } from './migrations.js';
 import { createMigration } from './migrations/files.js';
 const help = `tenon migrate|status|rollback [--directory migrations] [--namespace public]
@@ -12,8 +12,10 @@ baseline capture: [--schema name ...] (default: whole database schema)
 tenon new <name> [--directory migrations] (no database required)
 tenon generate [--namespace public] [--out src/generated-schema.ts] [--check]
 tenon describe <query.sql> [--role name] [--search-path schemas] [--time-zone zone]
+tenon check [file.ts[:line]] [--project tsconfig.json] [--json]
 describe: [--connect-timeout-ms 3000] [--statement-timeout-ms 5000] [--lock-timeout-ms 1000]
 describe emits JSON metadata; it does not execute the query or verify result annotations.
+check compares source contracts; mismatches, unchecked sites and no sites fail. Unproven types are notes.
 rollback: --steps 1
 Connection: DATABASE_URL
 `;
@@ -44,6 +46,8 @@ async function main() {
             check: { type: 'boolean', default: false },
             steps: { type: 'string', default: '1' },
             help: { type: 'boolean', default: false },
+            project: { type: 'string' },
+            json: { type: 'boolean', default: false },
             ...describeFlags,
         },
     });
@@ -55,9 +59,9 @@ async function main() {
     // Validate explicitly supplied flags, not defaults. Silently ignoring --check
     // on migrate, for example, would turn an intended dry run into a schema change.
     const allowed = new Set(['help']);
-    if (command !== 'generate' && command !== 'describe')
+    if (command !== 'generate' && command !== 'describe' && command !== 'check')
         allowed.add('directory');
-    if (command !== 'new' && command !== 'describe') {
+    if (command !== 'new' && command !== 'describe' && command !== 'check') {
         allowed.add('namespace');
     }
     if (command === 'generate') {
@@ -70,7 +74,11 @@ async function main() {
     if (command === 'baseline' && argument === 'capture') {
         allowed.add('schema');
     }
-    if (command === 'describe') {
+    if (command === 'check') {
+        allowed.add('project');
+        allowed.add('json');
+    }
+    if (command === 'describe' || command === 'check') {
         for (const name of Object.keys(describeFlags))
             allowed.add(name);
     }
@@ -88,12 +96,14 @@ async function main() {
         return;
     }
     const baseline = command === 'baseline' && (argument === 'capture' || argument === 'adopt');
-    const valid = baseline || command === 'describe'
-        ? positionals.length === 2
-        : positionals.length === 1 &&
-            ['migrate', 'generate', 'status', 'rollback'].includes(command ?? '');
+    const valid = command === 'check'
+        ? positionals.length <= 2
+        : baseline || command === 'describe'
+            ? positionals.length === 2
+            : positionals.length === 1 &&
+                ['migrate', 'generate', 'status', 'rollback'].includes(command ?? '');
     if (!valid) {
-        throw new Error('Choose new, baseline capture|adopt, migrate, generate, describe <query.sql>, status, or rollback. Use --help for options.');
+        throw new Error('Choose new, baseline capture|adopt, migrate, generate, describe <query.sql>, check [file.ts[:line]], status, or rollback. Use --help for options.');
     }
     const connection = process.env.DATABASE_URL;
     if (!connection) {
@@ -103,6 +113,25 @@ async function main() {
         await runDescribe(argument, connection, values);
         return;
     }
+    if (command === 'check') {
+        const { checkQueries } = await import('./check.js');
+        const report = await checkQueries({
+            connection,
+            ...(argument === undefined ? {} : { target: argument }),
+            ...(values.project === undefined ? {} : { project: values.project }),
+            ...inspectionSettings(values),
+        });
+        if (values.json)
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        else {
+            for (const diagnostic of report.diagnostics)
+                process.stdout.write(`${diagnostic.file}:${diagnostic.line}:${diagnostic.column} [${diagnostic.kind}] ${diagnostic.code}: ${diagnostic.message}\n`);
+            process.stdout.write(`${report.queries.length} queries, ${report.queries.filter((query) => query.status === 'analysed').length} analysed, ${report.queries.filter((query) => query.status === 'unchecked').length} unchecked, ${report.queries.reduce((count, query) => count + query.variants, 0)} variants described; ${report.diagnostics.filter((diagnostic) => diagnostic.kind === 'mismatch').length} mismatches, ${report.diagnostics.filter((diagnostic) => diagnostic.kind === 'unproven').length} unproven findings.\n`);
+        }
+        if (!report.ok)
+            process.exitCode = 1;
+        return;
+    }
     const options = { connection, directory: values.directory, namespace: values.namespace };
     if (baseline) {
         await runBaseline(argument, {

package/dist/connection.d.ts

@@ -1,19 +1,12 @@
-import { Pool, type PoolClient, type PoolConfig, type QueryResult as PgResult } from 'pg';
+import { type Pool, type PoolOptions, type QueryResult as DriverResult, type Executor } from '@kequtech/pgclear';
 import type { UnknownRow } from './query.js';
-export type ConnectionOptions = PoolConfig;
+export type ConnectionOptions = PoolOptions;
 export type Connection = string | ConnectionOptions | Pool;
-export type QueryResult<Row extends object = UnknownRow> = PgResult<Row>;
+export type QueryResult<Row extends object = UnknownRow> = DriverResult<Row>;
 export type QueryExecutor = <T>(text: string, input: readonly unknown[], readResult: (result: QueryResult) => T, guarded: boolean) => Promise<T>;
-/** Own constructed pools; supplied pools retain their application's ownership and error policy. */
+/** Constructed pools are owned; supplied public pgclear pools remain application-owned. */
 export declare function createConnection(connection: Connection): {
     pool: Pool;
-    run<T>(work: () => Promise<T>): Promise<T>;
     close(timeoutMs: number): Promise<void>;
 };
-/** A checked-out pg client remains tied to its session and is discarded after a failure. */
-export declare function watchClient(client: PoolClient): {
-    check(): void;
-    release(error?: Error): void;
-};
-/** Unnamed extended protocol enforces a single statement, even without parameters. */
-export declare function executeSql(connection: Pool | PoolClient, text: string, input?: readonly unknown[]): Promise<PgResult<UnknownRow>>;
+export declare function executeSql(connection: Executor, text: string, input?: readonly unknown[]): Promise<QueryResult>;

package/dist/connection.js

@@ -1,132 +1,23 @@
-import { Pool, } from 'pg';
+import { createPool, } from '@kequtech/pgclear';
 import { plainObject } from './validation.js';
-/** A supplied pool may come from another installed copy of pg. */
 function isPool(connection) {
     return (connection !== null &&
         typeof connection === 'object' &&
-        'connect' in connection &&
-        typeof connection.connect === 'function' &&
-        'query' in connection &&
-        typeof connection.query === 'function' &&
-        'totalCount' in connection &&
-        typeof connection.totalCount === 'number' &&
-        'end' in connection &&
-        typeof connection.end === 'function');
+        'acquire' in connection &&
+        typeof connection.acquire === 'function' &&
+        'close' in connection &&
+        typeof connection.close === 'function' &&
+        'stats' in connection);
 }
-/** Own constructed pools; supplied pools retain their application's ownership and error policy. */
+/** Constructed pools are owned; supplied public pgclear pools remain application-owned. */
 export function createConnection(connection) {
     if (isPool(connection))
-        return { pool: connection, run: (work) => work(), close: async () => { } };
-    let config;
-    if (typeof connection === 'string') {
-        if (!connection.trim())
-            throw new Error('Connection string must not be empty.');
-        config = { connectionString: connection };
-    }
-    else {
+        return { pool: connection, close: async () => { } };
+    if (typeof connection !== 'string')
         plainObject(connection, 'Connection configuration');
-        if ('url' in connection) {
-            throw new Error('Use pg connectionString in the connection configuration instead of url/options.');
-        }
-        config = connection;
-    }
-    const pool = new Pool(config);
-    const clients = new Set();
-    const pending = new Map();
-    let terminating = false;
-    const terminate = (client) => {
-        void client.end().catch(() => { });
-    };
-    // pool.end handles idle clients; the deadline also ends native checkouts.
-    pool.on('acquire', (client) => {
-        clients.add(client);
-        if (terminating)
-            terminate(client);
-    });
-    pool.on('release', (_error, client) => clients.delete(client));
-    pool.on('error', (error) => process.emitWarning(error));
-    return {
-        pool,
-        run(work) {
-            let expire;
-            const task = new Promise((resolve, reject) => {
-                expire = reject;
-                void Promise.resolve().then(work).then(resolve, reject);
-            });
-            pending.set(task, expire);
-            const forget = () => {
-                pending.delete(task);
-            };
-            void task.then(forget, forget);
-            return task;
-        },
-        async close(timeoutMs) {
-            let timer;
-            let ending;
-            const end = () => (ending ??= pool.end());
-            try {
-                await Promise.race([
-                    (async () => {
-                        await Promise.allSettled([...pending.keys()]);
-                        await end();
-                    })(),
-                    new Promise((resolve) => {
-                        timer = setTimeout(resolve, timeoutMs);
-                    }).then(async () => {
-                        // Native callbacks must reject close on failure, not escape a timer callback.
-                        terminating = true;
-                        const error = new Error('The database shutdown deadline expired.');
-                        for (const reject of pending.values())
-                            reject(error);
-                        try {
-                            void end().catch(() => { });
-                        }
-                        finally {
-                            // Attempt every checkout even when one native end call throws.
-                            await Promise.all([...clients].map(async (client) => terminate(client)));
-                        }
-                    }),
-                ]);
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        },
-    };
+    const pool = createPool(connection);
+    return { pool, close: (timeoutMs) => pool.close({ timeoutMs }) };
 }
-/** A checked-out pg client remains tied to its session and is discarded after a failure. */
-export function watchClient(client) {
-    let failure;
-    const onError = (error) => {
-        failure ??= error;
-    };
-    const onEnd = () => {
-        failure ??= new Error('The PostgreSQL connection closed.');
-    };
-    client.on('error', onError);
-    client.on('end', onEnd);
-    return {
-        check() {
-            if (failure)
-                throw failure;
-        },
-        release(error) {
-            try {
-                client.release(error ?? failure);
-            }
-            finally {
-                client.removeListener('error', onError);
-                client.removeListener('end', onEnd);
-            }
-        },
-    };
-}
-/** Unnamed extended protocol enforces a single statement, even without parameters. */
 export function executeSql(connection, text, input = []) {
-    const config = {
-        text,
-        values: [...input],
-        queryMode: 'extended',
-    };
-    return connection.query(config);
+    return connection.queryClassic(text, input);
 }

package/dist/database.js

@@ -26,7 +26,7 @@ export function createTenon(options) {
     if (options.onQuery !== undefined && typeof options.onQuery !== 'function') {
         throw new Error('onQuery must be a function.');
     }
-    const { pool, run, close } = createConnection(options.connection);
+    const { pool, close } = createConnection(options.connection);
     let closing;
     function checkOpen() {
         if (closing) {
@@ -35,19 +35,16 @@ export function createTenon(options) {
     }
     const query = (text, input, readResult, guarded) => {
         checkOpen();
-        return run(async () => {
-            if (guarded) {
-                return withTransaction(pool, (query) => query(text, input, readResult, false));
-            }
-            return readResult(await executeSql(pool, text, input));
-        });
+        if (guarded)
+            return withTransaction(pool, (query) => query(text, input, readResult, false));
+        return executeSql(pool, text, input).then(readResult);
     };
     return {
         ...createClient(query, options.onQuery),
         native: pool,
         async transaction(callback) {
             checkOpen();
-            return run(() => withTransaction(pool, (query) => callback(createClient(query, options.onQuery))));
+            return withTransaction(pool, (query) => callback(createClient(query, options.onQuery)));
         },
         close(options) {
             if (closing)

package/dist/describe.js

@@ -1,3 +1,4 @@
+import { defaultCodecs } from '@kequtech/pgclear';
 import { readStatementMetadata } from './inspection/catalog.js';
 import { withInspectionConnection } from './inspection/connection.js';
 import { queryDescription } from './inspection/result.js';
@@ -6,7 +7,7 @@ import { plainObject } from './validation.js';
 export async function describeQuery(options) {
     const input = plainObject(options, 'Describe options');
     for (const key of Object.keys(input)) {
-        if (!['connection', 'query', 'session', 'timeouts'].includes(key)) {
+        if (!['connection', 'query', 'session', 'timeouts', 'codecs'].includes(key)) {
             throw new Error(`Unknown Describe option: ${key}`);
         }
     }
@@ -16,6 +17,12 @@ export async function describeQuery(options) {
     if (typeof text !== 'string' || !text.trim()) {
         throw new Error('Describe query requires nonempty SQL text or a query object with text.');
     }
-    const query = text;
-    return withInspectionConnection(options, async (client, context) => queryDescription(await readStatementMetadata(client, query), context));
+    const query = {
+        text,
+        ...(typeof options.query === 'object' && options.query.parameterTypes !== undefined
+            ? { parameterTypes: [...options.query.parameterTypes] }
+            : {}),
+    };
+    const codecs = options.codecs ?? defaultCodecs;
+    return withInspectionConnection(options, async (client, context) => queryDescription(await readStatementMetadata(client, query), context, codecs));
 }

package/dist/generate.d.ts

@@ -2,8 +2,7 @@ import type { Connection } from './connection.js';
 export interface GenerateOptions {
     readonly connection: Connection;
     readonly namespace?: string;
-    /** Receives generation warnings; defaults to console.warn. */
-    readonly onWarning?: (message: string) => void;
+    readonly onWarning?: (message: string) => void | Promise<void>;
 }
-/** Read-only introspection. Output needs no runtime imports or schema registration. */
+/** Read one schema snapshot with default catalog codecs and the selected application read mappings. */
 export declare function generateDefinitions(options: GenerateOptions): Promise<string>;

package/dist/generate.js

@@ -1,34 +1,36 @@
+import { defaultCodecs } from '@kequtech/pgclear';
 import { readTables } from './generation/catalog.js';
-import { renderTableTypes } from './generation/table-types.js';
+import { renderDatabase } from './generation/render.js';
 import { domainSummaries, schemaSummary, tableSummary } from './generation/schema-summary.js';
 import { withMigrationLock } from './migrations/connection.js';
+import { migrationTable } from './migrations/history.js';
 import { quote } from './sql.js';
-/** Read-only introspection. Output needs no runtime imports or schema registration. */
+/** Read one schema snapshot with default catalog codecs and the selected application read mappings. */
 export async function generateDefinitions(options) {
-    const onWarning = options.onWarning ?? ((message) => console.warn(`Warning: ${message}`));
-    return withMigrationLock(options, 'shared', async (client, namespace) => {
-        await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY');
-        const schema = await client.query('SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = $1', [
-            namespace,
-        ]);
+    if (options.onWarning !== undefined && typeof options.onWarning !== 'function') {
+        throw new Error('onWarning must be a function.');
+    }
+    const warn = options.onWarning ?? ((message) => console.warn('Warning: ' + message));
+    return withMigrationLock(options, 'shared', (client, namespace) => client.transaction(async (transaction) => {
+        const catalog = {
+            query: (text, values = []) => transaction.queryClassic(text, values, { codecs: defaultCodecs }),
+        };
+        const schema = await catalog.query('SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = $1', [namespace]);
         if (!schema.rows.length)
             throw new Error(`Schema ${quote(namespace)} does not exist.`);
-        // Keep catalog deparsing stable across connection settings and replay schemas.
-        // Transaction-local settings are restored before returning a borrowed client.
-        await client.query(`SET LOCAL search_path TO pg_catalog, ${quote(namespace)}`);
-        await client.query('SET LOCAL quote_all_identifiers TO off');
-        await client.query('SET LOCAL standard_conforming_strings TO on');
-        const definitions = await readTables(client, namespace);
+        await catalog.query(`SET LOCAL search_path TO pg_catalog, ${quote(namespace)}`);
+        await catalog.query('SET LOCAL quote_all_identifiers TO off');
+        await catalog.query('SET LOCAL standard_conforming_strings TO on');
+        const tables = await readTables(catalog, namespace, [migrationTable]);
         const summaries = [];
-        for (const table of definitions) {
-            summaries.push(await tableSummary(client, table.oid, table.name));
+        for (const table of tables) {
+            summaries.push(await tableSummary(catalog, table.oid, table.name));
         }
-        const domains = await domainSummaries(client, definitions.flatMap((table) => table.columns.map((column) => column.declaredOid)));
-        const types = renderTableTypes(definitions, namespace, onWarning);
-        await client.query('COMMIT');
-        return `// Generated by Tenon from the PostgreSQL schema. Do not edit.
-// Commit this file and regenerate it after changing the schema.
-
-${schemaSummary([...domains, ...summaries])}${types}`;
-    });
+        const domains = await domainSummaries(catalog, tables.flatMap((table) => table.columns.map((column) => column.declaredOid)));
+        const warnings = [];
+        const types = renderDatabase(tables, namespace, transaction.codecs, (message) => warnings.push(message));
+        for (const warning of warnings)
+            await warn(warning);
+        return `// Generated by Tenon from the PostgreSQL schema. Do not edit.\n\n${schemaSummary([...domains, ...summaries])}${types}`;
+    }, { isolation: 'repeatable read', readOnly: true }));
 }

package/dist/generation/catalog.d.ts

@@ -1,13 +1,12 @@
-import type { PoolClient } from 'pg';
+import { type InputValue, type QueryResult, type Row } from '@kequtech/pgclear';
+export interface CatalogClient {
+    query<T extends object = Row>(text: string, values?: readonly InputValue[]): Promise<QueryResult<T>>;
+}
 export interface ColumnRow {
     name: string;
     oid: string;
-    type: string;
-    typeSchema: string;
     typeKind: string;
     declaredOid: string;
-    declaredType: string;
-    declaredSchema: string;
     nullable: boolean;
     writeNullable: boolean;
     hasDefault: boolean;
@@ -19,4 +18,4 @@ export interface TableRow {
     name: string;
     columns: ColumnRow[];
 }
-export declare function readTables(client: PoolClient, namespace: string): Promise<TableRow[]>;
+export declare function readTables(client: CatalogClient, namespace: string, exclude: readonly string[]): Promise<TableRow[]>;

package/dist/generation/catalog.js

@@ -1,11 +1,11 @@
-import { migrationTable } from '../migrations/history.js';
-export async function readTables(client, namespace) {
+import { builtin, param } from '@kequtech/pgclear';
+export async function readTables(client, namespace, exclude) {
     const tables = await client.query(`
       SELECT c.oid::text AS oid, c.relname AS name
       FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-      WHERE n.nspname = $1 AND c.relname <> $2 AND c.relkind IN ('r', 'p')
+      WHERE n.nspname = $1 AND NOT (c.relname = ANY($2::text[])) AND c.relkind IN ('r', 'p')
         AND NOT c.relispartition
-      ORDER BY c.relname COLLATE "C"`, [namespace, migrationTable]);
+      ORDER BY c.relname COLLATE "C"`, [namespace, param(exclude, builtin.textArray)]);
     const definitions = [];
     for (const table of tables.rows) {
         // Attached descendants are storage details, not separate generated models.
@@ -18,8 +18,8 @@ export async function readTables(client, namespace) {
           SELECT r.attnum, t.oid, t.typbasetype, r.domain_not_null OR t.typnotnull
           FROM resolved r JOIN pg_catalog.pg_type t ON t.oid = r.typbasetype
         )
-        SELECT a.attname AS name, t.oid::text AS oid, t.typname AS type, tn.nspname AS "typeSchema", t.typtype AS "typeKind",
-          declared.oid::text AS "declaredOid", declared.typname AS "declaredType", dn.nspname AS "declaredSchema",
+        SELECT a.attname AS name, t.oid::text AS oid, t.typtype AS "typeKind",
+          declared.oid::text AS "declaredOid",
           NOT a.attnotnull AS nullable,
           NOT (a.attnotnull OR r.domain_not_null) AS "writeNullable",
           (a.atthasdef OR declared.typdefaultbin IS NOT NULL OR a.attidentity <> '') AS "hasDefault",
@@ -28,11 +28,9 @@ export async function readTables(client, namespace) {
         FROM pg_catalog.pg_attribute a
           JOIN resolved r ON r.attnum = a.attnum AND r.typbasetype = 0
           JOIN pg_catalog.pg_type t ON t.oid = r.oid
-          JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace
           JOIN pg_catalog.pg_type declared ON declared.oid = a.atttypid
-          JOIN pg_catalog.pg_namespace dn ON dn.oid = declared.typnamespace
         WHERE a.attrelid = $1::oid AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum`, [table.oid]);
-        definitions.push({ ...table, columns: columns.rows });
+        definitions.push({ ...table, columns: [...columns.rows] });
     }
     return definitions;
 }

package/dist/generation/render.d.ts

@@ -0,0 +1,3 @@
+import { type CodecRegistry } from '@kequtech/pgclear';
+import type { TableRow } from './catalog.js';
+export declare function renderDatabase(tables: readonly TableRow[], namespace: string, codecs: CodecRegistry, warn: (message: string) => void): string;