@bockit/sequel 0.0.0-stage → 0.2.0

package/dist/migrate/lint.js

@@ -0,0 +1,153 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { SequelError } from '../errors.js';
+import { compare } from './files.js';
+import { addedEnumValue, buildsIndexConcurrently, indexWithoutUsing, noTransactionMarker, } from './sql-text.js';
+// TECH-SPEC §8: sequel's default Squawk config, for an app with no `.squawk.toml`. The excluded
+// rules fire on Prisma's own output, or on timeouts the runner sets itself.
+export const DEFAULT_SQUAWK_CONFIG = `pg_version = "18.0"
+excluded_rules = [
+  "prefer-bigint-over-int",
+  "prefer-identity",
+  "require-enum-value-ordering",
+  "require-lock-timeout",
+  "require-statement-timeout",
+]
+`;
+export const SQUAWK_CONFIG_FILE = '.squawk.toml';
+// The migrations `migrate lint` and `check` lint: those after the cut-over. Files at or before
+// it are already applied, and their checksums are fixed.
+export function migrationsToLint(migrations, cutover) {
+    return cutover === undefined
+        ? migrations
+        : migrations.filter((m) => compare(m.identity, cutover) > 0);
+}
+// Squawk, then sequel's own rules, over the files. Transactional files are linted as running
+// in a transaction, and no-transaction files as not.
+export async function lintMigrations(options) {
+    const { migrations, root } = options;
+    if (migrations.length === 0)
+        return [];
+    const findings = [];
+    const appConfig = path.join(root, SQUAWK_CONFIG_FILE);
+    const workDir = existsSync(appConfig)
+        ? undefined
+        : await mkdtemp(path.join(tmpdir(), 'sequel-squawk-'));
+    try {
+        let config = appConfig;
+        if (workDir !== undefined) {
+            config = path.join(workDir, SQUAWK_CONFIG_FILE);
+            await writeFile(config, DEFAULT_SQUAWK_CONFIG);
+        }
+        for (const inTransaction of [true, false]) {
+            const group = migrations.filter((m) => m.noTransaction !== inTransaction);
+            if (group.length === 0)
+                continue;
+            findings.push(...(await runSquawk(options.squawk, config, group, inTransaction, root)));
+        }
+    }
+    finally {
+        if (workDir !== undefined)
+            await rm(workDir, { recursive: true, force: true });
+    }
+    for (const migration of migrations)
+        findings.push(...ownRules(migration, options.unsupported));
+    return findings.sort((a, b) => compare(a.shown, b.shown) ||
+        a.line - b.line ||
+        a.column - b.column ||
+        compare(a.rule, b.rule));
+}
+export function formatFinding(finding) {
+    return `${finding.shown}:${finding.line}:${finding.column}: ${finding.rule}: ${finding.message}`;
+}
+function runSquawk(squawk, config, migrations, inTransaction, root) {
+    const byFile = new Map(migrations.map((m) => [m.file, m]));
+    const args = [
+        '--config',
+        config,
+        '--reporter',
+        'json',
+        inTransaction ? '--assume-in-transaction' : '--no-assume-in-transaction',
+        ...migrations.map((m) => m.file),
+    ];
+    return new Promise((resolve, reject) => {
+        execFile(squawk, args, { cwd: root, maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error !== null && typeof error.code !== 'number') {
+                reject(error);
+                return;
+            }
+            let violations;
+            try {
+                violations = stdout.trim() === '' ? [] : JSON.parse(stdout);
+            }
+            catch {
+                reject(new SequelError(`Squawk failed (exit ${error?.code ?? 0}): ${(stderr || stdout).trim()}`));
+                return;
+            }
+            if (error !== null && violations.length === 0) {
+                reject(new SequelError(`Squawk failed (exit ${error.code}): ${(stderr || stdout).trim()}`));
+                return;
+            }
+            // Squawk counts lines and columns from 0.
+            resolve(violations.map((v) => ({
+                shown: byFile.get(path.resolve(root, v.file))?.shown ?? path.relative(root, v.file),
+                line: v.line + 1,
+                column: v.column + 1,
+                rule: v.rule_name,
+                message: v.help ? `${v.message} (${v.help})` : v.message,
+            })));
+        });
+    });
+}
+// sequel's own rules. None can be suppressed: Postgres or the runner would reject the files
+// most of them flag, and the index rule is satisfied by writing the method, even `USING btree`.
+export function ownRules(migration, unsupported = new Map()) {
+    const findings = [];
+    const { statements } = migration.scanned;
+    const at = (line, rule, message) => findings.push({ shown: migration.shown, line, column: 1, rule, message });
+    statements.forEach((statement, i) => {
+        const value = addedEnumValue(statement);
+        if (value === undefined)
+            return;
+        for (const later of statements.slice(i + 1)) {
+            if (later.tokens.some((t) => t.kind === 'string' && t.value === value)) {
+                at(later.line, 'enum-value-used-in-same-file', `the enum value '${value}' is added on line ${statement.line} of this file and used here. Postgres won't use a new enum value until the transaction that adds it commits: move this statement into a later migration.`);
+            }
+        }
+    });
+    if (migration.noTransaction && statements.length > 1) {
+        at(statements[1]?.line ?? 1, 'no-transaction-multiple-statements', `this no-transaction file holds ${statements.length} statements. A no-transaction file holds exactly one: split it into one file per statement.`);
+    }
+    // Squawk flags this only after an explicit BEGIN, not under --assume-in-transaction.
+    if (!migration.noTransaction) {
+        for (const statement of statements.filter(buildsIndexConcurrently)) {
+            at(statement.line, 'concurrent-index-in-transaction', 'this builds an index concurrently, which Postgres refuses inside a transaction, and this file runs in one. Put it alone in a file with `-- sequel:no-transaction` above its first statement.');
+        }
+    }
+    for (const statement of statements) {
+        const index = indexWithoutUsing(statement);
+        const columns = index === undefined ? undefined : unsupported.get(index.table);
+        if (index === undefined || columns === undefined)
+            continue;
+        for (const column of new Set(index.identifiers)) {
+            const type = columns.get(column);
+            if (type === undefined)
+                continue;
+            at(statement.line, 'unsupported-column-index-without-using', `this index on ${index.table}.${column}, which the schema declares as Unsupported("${type}"), gives no USING, so Postgres builds a btree index. Give the access method and operator class, such as \`USING hnsw ("${column}" vector_cosine_ops)\` for a pgvector column, or write \`USING btree\` if a btree index is what you mean.`);
+        }
+    }
+    for (const line of noTransactionMarker(migration.scanned).misplacedLines) {
+        at(line, 'no-transaction-marker-after-statement', 'the `-- sequel:no-transaction` marker comes after the first statement, so it marks nothing. Move it above the first statement.');
+    }
+    return findings;
+}
+// The message for a lint run with findings: one line each, then how to deal with them.
+export function lintFailureMessage(findings) {
+    return [
+        ...findings.map(formatFinding),
+        `${findings.length} lint finding${findings.length === 1 ? '' : 's'}. Fix each, or suppress a Squawk finding with \`-- squawk-ignore <rule> -- <reason>\` on the line above it. sequel's own rules can't be suppressed: change the file.`,
+    ].join('\n');
+}

package/dist/migrate/new.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedConfig } from '../config/resolve-config.ts';
+import { type LintFinding } from './lint.ts';
+export type NewMigration = {
+    file: string | undefined;
+    findings: LintFinding[];
+};
+export declare function newMigration(options: {
+    config: ResolvedConfig;
+    name: string;
+    now?: Date;
+    engineBinary?: string;
+    squawk?: string;
+}): Promise<NewMigration>;

package/dist/migrate/new.js

@@ -0,0 +1,41 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ensureBinary } from '../binaries/ensure-binary.js';
+import { SequelError } from '../errors.js';
+import { assertValidSchema, readSchemaFiles } from '../schema/schema.js';
+import { unsupportedColumns } from '../schema/unsupported.js';
+import { diffMigrationsToSchema } from './drift.js';
+import { findMigrations, migrationIdentity, readMigrationFile } from './files.js';
+import { lintMigrations } from './lint.js';
+// TECH-SPEC §8: diff the migrations, replayed in a shadow database, against the schema folder,
+// write the difference as a new file at the top of the migrations folder, and lint it. It
+// never connects to the target database.
+export async function newMigration(options) {
+    const { config } = options;
+    const identity = migrationIdentity(options.now ?? new Date(), options.name);
+    const files = await readSchemaFiles(config.schema, config.root);
+    assertValidSchema(files, config.root);
+    const migrations = await findMigrations(config.migrations, { root: config.root });
+    const file = path.join(config.migrations, `${identity}.sql`);
+    const clash = migrations.find((m) => m.identity === identity);
+    if (clash !== undefined) {
+        throw new SequelError(`${clash.shown} already exists. Wait a second and run \`sequel migrate new\` again, or choose another name.`);
+    }
+    const diff = await diffMigrationsToSchema({
+        config,
+        migrations,
+        files,
+        ...(options.engineBinary === undefined ? {} : { engineBinary: options.engineBinary }),
+    });
+    if (!diff.changed)
+        return { file: undefined, findings: [] };
+    await mkdir(config.migrations, { recursive: true });
+    await writeFile(file, diff.sql, { flag: 'wx' });
+    const findings = await lintMigrations({
+        squawk: options.squawk ?? (await ensureBinary('squawk')),
+        migrations: [await readMigrationFile(file, config.root)],
+        root: config.root,
+        unsupported: unsupportedColumns(files),
+    });
+    return { file, findings };
+}

package/dist/migrate/runner.d.ts

@@ -0,0 +1,28 @@
+import { type Migration } from './files.ts';
+export type DeployOptions = {
+    url: string;
+    migrations: Migration[];
+    timeouts: {
+        lockMs: number;
+        statementMs: number;
+    };
+    allowOutOfOrder?: boolean;
+    log?: (message: string) => void;
+    lockWaitMs?: number;
+};
+export type DeployResult = {
+    applied: Migration[];
+    newerApplied: string[];
+    historySchema: string;
+};
+export declare function deployMigrations(options: DeployOptions): Promise<DeployResult>;
+type Plan = {
+    pending: Migration[];
+    newerApplied: string[];
+    problems: string[];
+};
+export declare function planDeploy(migrations: Migration[], history: {
+    name: string;
+    sha256: string;
+}[], database: string, allowOutOfOrder?: boolean): Plan;
+export {};

package/dist/migrate/runner.js

@@ -0,0 +1,124 @@
+import { databaseName, withClient } from '../db/connection.js';
+import { SequelError } from '../errors.js';
+import { compare } from './files.js';
+import { acquireLock, createHistoryTable, historyState, readHistory, recordMigration, releaseLock, } from './history.js';
+import { buildsIndexConcurrently, lineAt } from './sql-text.js';
+// TECH-SPEC §8's runner: one connection, sequel's advisory lock for the whole run, every check
+// before anything is applied, then one transaction per file.
+export async function deployMigrations(options) {
+    const database = databaseName(options.url);
+    return withClient(options.url, async (client) => {
+        client.on('error', () => { });
+        await acquireLock(client, database, options.lockWaitMs);
+        try {
+            const state = await historyState(client, database);
+            if (state.hasPrismaHistory && !state.hasHistory) {
+                throw new SequelError(`${database} has a Prisma migration history (_prisma_migrations) but no sequel history, so nothing was applied. Run \`sequel migrate adopt-prisma\` against it first.`);
+            }
+            const history = state.hasHistory ? await readHistory(client) : [];
+            const plan = planDeploy(options.migrations, history, database, options.allowOutOfOrder);
+            if (plan.problems.length > 0) {
+                throw new SequelError(`Refusing to deploy to ${database}, so nothing was applied:\n${plan.problems.map((p) => `  - ${p}`).join('\n')}`);
+            }
+            if (!state.hasHistory)
+                await createHistoryTable(client);
+            const applied = [];
+            for (const migration of plan.pending) {
+                if (migration.noTransaction)
+                    await applyWithoutTransaction(client, migration, options);
+                else
+                    await applyInTransaction(client, migration, options);
+                applied.push(migration);
+                options.log?.(`Applied ${migration.shown}`);
+            }
+            return { applied, newerApplied: plan.newerApplied, historySchema: state.schema };
+        }
+        finally {
+            await releaseLock(client).catch(() => { });
+        }
+    });
+}
+export function planDeploy(migrations, history, database, allowOutOfOrder = false) {
+    const files = new Map(migrations.map((m) => [m.identity, m]));
+    const applied = new Set(history.map((row) => row.name));
+    const newestFile = migrations.at(-1)?.identity;
+    const problems = [];
+    const newerApplied = [];
+    for (const row of history) {
+        const file = files.get(row.name);
+        if (file === undefined) {
+            if (newestFile === undefined || compare(row.name, newestFile) > 0) {
+                newerApplied.push(row.name);
+            }
+            else {
+                problems.push(`\`${row.name}\` is applied to ${database}, but no migration file has that name. An applied migration is never deleted or renamed: restore its file from version control.`);
+            }
+        }
+        else if (file.sha256 !== row.sha256) {
+            problems.push(`${file.shown} has changed since it was applied to ${database} (sha256 ${row.sha256} then, ${file.sha256} now). An applied migration is immutable: restore the file from version control, and make the change in a new migration.`);
+        }
+    }
+    const newestApplied = history
+        .map((row) => row.name)
+        .sort(compare)
+        .at(-1);
+    const pending = migrations.filter((m) => !applied.has(m.identity));
+    for (const migration of pending) {
+        if (!allowOutOfOrder &&
+            newestApplied !== undefined &&
+            compare(migration.identity, newestApplied) < 0) {
+            problems.push(`${migration.shown} is pending, but sorts before \`${newestApplied}\`, the newest migration applied to ${database}. Give it a newer timestamp, or deploy with --allow-out-of-order if it is safe to apply out of order.`);
+        }
+        const statements = migration.scanned.statements.length;
+        if (migration.noTransaction && statements > 1) {
+            problems.push(`${migration.shown} is marked \`-- sequel:no-transaction\` but holds ${statements} statements. A no-transaction file holds exactly one: split it into one file per statement.`);
+        }
+    }
+    return { pending, newerApplied, problems };
+}
+async function applyInTransaction(client, migration, options) {
+    await client.query('BEGIN');
+    try {
+        await client.query(`SET LOCAL lock_timeout = '${options.timeouts.lockMs}ms'`);
+        await client.query(`SET LOCAL statement_timeout = '${options.timeouts.statementMs}ms'`);
+        // One simple-protocol query: pg sends a query with no parameters as text, as psql would.
+        await client.query(migration.text);
+        await recordMigration(client, migration.identity, migration.sha256);
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        await client.query('ROLLBACK').catch(() => { });
+        throw failure(migration, error, 'Nothing of it was applied');
+    }
+}
+async function applyWithoutTransaction(client, migration, options) {
+    await client.query(`SET lock_timeout = '${options.timeouts.lockMs}ms'`);
+    await client.query('SET statement_timeout = 0');
+    try {
+        await client.query(migration.text);
+        await recordMigration(client, migration.identity, migration.sha256);
+    }
+    catch (error) {
+        const concurrent = migration.scanned.statements.some(buildsIndexConcurrently);
+        throw failure(migration, error, concurrent
+            ? 'It is not recorded. A failed concurrent index build can leave an invalid index behind: drop it with `DROP INDEX CONCURRENTLY` before deploying again'
+            : 'It is not recorded');
+    }
+    finally {
+        await client.query('RESET lock_timeout').catch(() => { });
+        await client.query('RESET statement_timeout').catch(() => { });
+    }
+}
+function failure(migration, error, outcome) {
+    const pgError = error;
+    if (pgError.message === undefined)
+        return error;
+    const position = Number(pgError.position);
+    const at = Number.isInteger(position) && position > 0 ? `:${lineAt(migration.text, position - 1)}` : '';
+    const extra = [pgError.detail, pgError.hint].filter((s) => Boolean(s));
+    return new SequelError([
+        `${migration.shown}${at}: ${pgError.message}`,
+        ...extra.map((line) => `  ${line}`),
+        `${outcome}; the files before it stay applied, and the deploy stopped there. Fix the file and deploy again.`,
+    ].join('\n'));
+}

package/dist/migrate/sql-text.d.ts

@@ -0,0 +1,33 @@
+export type Token = {
+    kind: 'word' | 'string' | 'qident' | 'semicolon' | 'other';
+    value: string;
+    offset: number;
+};
+export type Comment = {
+    text: string;
+    offset: number;
+    block: boolean;
+};
+export type Statement = {
+    text: string;
+    offset: number;
+    line: number;
+    tokens: Token[];
+};
+export type ScannedSql = {
+    source: string;
+    statements: Statement[];
+    comments: Comment[];
+};
+export declare function scanSql(text: string): ScannedSql;
+export declare function lineAt(text: string, offset: number): number;
+export declare function noTransactionMarker(scanned: ScannedSql): {
+    noTransaction: boolean;
+    misplacedLines: number[];
+};
+export declare function buildsIndexConcurrently(statement: Statement): boolean;
+export declare function addedEnumValue(statement: Statement): string | undefined;
+export declare function indexWithoutUsing(statement: Statement): {
+    table: string;
+    identifiers: string[];
+} | undefined;

package/dist/migrate/sql-text.js

@@ -0,0 +1,233 @@
+// Just enough of Postgres's lexical rules to read a migration: comments (nested block comments
+// included), strings ('…', E'…' with backslash escapes, and dollar quotes), quoted identifiers,
+// and the semicolons between statements. Nothing here parses SQL.
+export function scanSql(text) {
+    const tokens = [];
+    const comments = [];
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (/\s/.test(c)) {
+            i++;
+        }
+        else if (c === '-' && next === '-') {
+            const end = text.indexOf('\n', i);
+            const stop = end === -1 ? n : end;
+            comments.push({ text: text.slice(i, stop), offset: i, block: false });
+            i = stop;
+        }
+        else if (c === '/' && next === '*') {
+            const start = i;
+            let depth = 0;
+            while (i < n) {
+                if (text[i] === '/' && text[i + 1] === '*') {
+                    depth++;
+                    i += 2;
+                }
+                else if (text[i] === '*' && text[i + 1] === '/') {
+                    depth--;
+                    i += 2;
+                    if (depth === 0)
+                        break;
+                }
+                else
+                    i++;
+            }
+            comments.push({ text: text.slice(start, i), offset: start, block: true });
+        }
+        else if (c === "'" || ((c === 'E' || c === 'e') && next === "'")) {
+            const start = i;
+            const escapes = c !== "'";
+            i += escapes ? 2 : 1;
+            let value = '';
+            while (i < n) {
+                const ch = text[i];
+                if (escapes && ch === '\\') {
+                    value += text[i + 1] ?? '';
+                    i += 2;
+                }
+                else if (ch === "'" && text[i + 1] === "'") {
+                    value += "'";
+                    i += 2;
+                }
+                else if (ch === "'") {
+                    i++;
+                    break;
+                }
+                else {
+                    value += ch;
+                    i++;
+                }
+            }
+            tokens.push({ kind: 'string', value, offset: start });
+        }
+        else if (c === '"') {
+            const start = i;
+            i++;
+            let value = '';
+            while (i < n) {
+                if (text[i] === '"' && text[i + 1] === '"') {
+                    value += '"';
+                    i += 2;
+                }
+                else if (text[i] === '"') {
+                    i++;
+                    break;
+                }
+                else
+                    value += text[i++];
+            }
+            tokens.push({ kind: 'qident', value, offset: start });
+        }
+        else if (c === '$' && /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.test(text.slice(i, i + 64))) {
+            const tag = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(text.slice(i))[0];
+            const start = i;
+            const close = text.indexOf(tag, i + tag.length);
+            const end = close === -1 ? n : close + tag.length;
+            tokens.push({
+                kind: 'string',
+                value: text.slice(i + tag.length, close === -1 ? n : close),
+                offset: start,
+            });
+            i = end;
+        }
+        else if (/[\p{L}_]/u.test(c)) {
+            const start = i;
+            while (i < n && /[\p{L}\p{N}_$]/u.test(text[i]))
+                i++;
+            tokens.push({ kind: 'word', value: text.slice(start, i), offset: start });
+        }
+        else if (c === ';') {
+            tokens.push({ kind: 'semicolon', value: ';', offset: i });
+            i++;
+        }
+        else {
+            tokens.push({ kind: 'other', value: c, offset: i });
+            i++;
+        }
+    }
+    const statements = [];
+    let current = [];
+    const finish = (end) => {
+        const first = current[0];
+        if (first !== undefined) {
+            statements.push({
+                text: text.slice(first.offset, end),
+                offset: first.offset,
+                line: lineAt(text, first.offset),
+                tokens: current,
+            });
+        }
+        current = [];
+    };
+    for (const token of tokens) {
+        if (token.kind === 'semicolon')
+            finish(token.offset + 1);
+        else
+            current.push(token);
+    }
+    finish(n);
+    return { source: text, statements, comments };
+}
+// The 1-based line of a 0-based offset.
+export function lineAt(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++)
+        if (text[i] === '\n')
+            line++;
+    return line;
+}
+const NO_TRANSACTION = /^--\s*sequel:no-transaction\s*$/;
+// TECH-SPEC §8: `-- sequel:no-transaction` on a line before the first statement.
+export function noTransactionMarker(scanned) {
+    const firstOffset = scanned.statements[0]?.offset ?? Infinity;
+    let noTransaction = false;
+    const misplaced = [];
+    for (const comment of scanned.comments) {
+        if (comment.block || !NO_TRANSACTION.test(comment.text.trim()))
+            continue;
+        if (comment.offset < firstOffset)
+            noTransaction = true;
+        else
+            misplaced.push(lineAt(scanned.source, comment.offset));
+    }
+    return { noTransaction, misplacedLines: misplaced };
+}
+const upper = (token) => token?.kind === 'word' ? token.value.toUpperCase() : undefined;
+// `CREATE [UNIQUE] INDEX CONCURRENTLY` or `REINDEX … CONCURRENTLY`.
+export function buildsIndexConcurrently(statement) {
+    const words = statement.tokens.map(upper);
+    const first = words[0];
+    return ((first === 'CREATE' || first === 'REINDEX') &&
+        words.includes('CONCURRENTLY') &&
+        (first === 'REINDEX' || words.includes('INDEX')));
+}
+// The value an `ALTER TYPE … ADD VALUE [IF NOT EXISTS] '<value>'` statement adds, if it is one.
+export function addedEnumValue(statement) {
+    const t = statement.tokens;
+    if (upper(t[0]) !== 'ALTER' || upper(t[1]) !== 'TYPE')
+        return undefined;
+    for (let i = 2; i < t.length - 1; i++) {
+        if (upper(t[i]) === 'ADD' && upper(t[i + 1]) === 'VALUE') {
+            let j = i + 2;
+            if (upper(t[j]) === 'IF' && upper(t[j + 1]) === 'NOT' && upper(t[j + 2]) === 'EXISTS')
+                j += 3;
+            const value = t[j];
+            return value?.kind === 'string' ? value.value : undefined;
+        }
+    }
+    return undefined;
+}
+// A `CREATE [UNIQUE] INDEX … ON <table> (…)` that gives no `USING`, so Postgres builds a btree
+// index: its table, without any schema, and the identifiers in its column list.
+export function indexWithoutUsing(statement) {
+    const t = statement.tokens;
+    if (upper(t[0]) !== 'CREATE')
+        return undefined;
+    const index = upper(t[1]) === 'UNIQUE' ? 2 : 1;
+    if (upper(t[index]) !== 'INDEX')
+        return undefined;
+    let i = t.findIndex((token, k) => k > index && upper(token) === 'ON');
+    if (i === -1)
+        return undefined;
+    i++;
+    if (upper(t[i]) === 'ONLY')
+        i++;
+    let table = name(t[i]);
+    while (t[i + 1]?.value === '.' && t[i + 2] !== undefined) {
+        i += 2;
+        table = name(t[i]);
+    }
+    i++;
+    if (table === undefined || upper(t[i]) === 'USING' || t[i]?.value !== '(')
+        return undefined;
+    const identifiers = [];
+    let depth = 0;
+    for (; i < t.length; i++) {
+        const token = t[i];
+        if (token.value === '(' && token.kind === 'other')
+            depth++;
+        else if (token.value === ')' && token.kind === 'other') {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+        else {
+            const identifier = name(token);
+            if (identifier !== undefined)
+                identifiers.push(identifier);
+        }
+    }
+    return { table, identifiers };
+}
+// An identifier as Postgres sees it: a quoted one as written, an unquoted one folded to
+// lower case.
+function name(token) {
+    if (token?.kind === 'qident')
+        return token.value;
+    if (token?.kind === 'word')
+        return token.value.toLowerCase();
+    return undefined;
+}

package/dist/schema/schema.d.ts

@@ -0,0 +1,16 @@
+export type SchemaFile = {
+    file: string;
+    relative: string;
+    content: string;
+};
+export declare function readSchemaFiles(folder: string, root: string): Promise<SchemaFile[]>;
+export declare function validateSchema(files: SchemaFile[], root: string): string | undefined;
+export type SchemaWarning = {
+    shown: string;
+    line: number;
+    message: string;
+};
+export declare function schemaWarnings(files: SchemaFile[], root: string): SchemaWarning[];
+export declare function assertValidSchema(files: SchemaFile[], root: string): void;
+export declare function invalidSchemaMessage(message: string): string;
+export declare function formatSchemaFiles(files: SchemaFile[], root: string): Promise<string[]>;