@rwillians/exto 0.1.1 → 0.1.2

package/dist/cjs/bun-postgres.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialect = exports.connect = void 0;
+const bun_1 = require("bun");
+const utils_1 = require("./utils");
+const TYPES = {
+    BIGINT: () => 'BIGINT',
+    BINARY: () => 'BYTEA',
+    BOOLEAN: () => 'BOOLEAN',
+    CITEXT: () => 'CITEXT',
+    DATE: () => 'DATE',
+    DATETIME: () => 'TIMESTAMPTZ',
+    DECIMAL: ({ precision, scale }) => [precision, scale].every(Number.isInteger) ? `NUMERIC(${precision}, ${scale})`
+        : [precision, scale].some(Number.isInteger) ? (0, utils_1.raise)('precision and scale are mutually inclusive, either you provide both or neither')
+            : 'NUMERIC',
+    FLOAT: () => 'DOUBLE PRECISION',
+    INTEGER: () => 'BIGINT',
+    JSON: () => 'JSONB',
+    SEQUENCE: () => 'BIGINT',
+    STRING: ({ length = 255 }) => `VARCHAR(${length})`,
+    TEXT: () => 'TEXT',
+    UUID: () => 'UUID',
+};
+const identity = () => ({
+    encode: (value) => value,
+    decode: (value) => value,
+});
+const dialect = {
+    name: 'postgres',
+    placeholder: (index) => `$${index}`,
+    type: (col) => TYPES[col.type](col),
+    generated: (col) => col.type === 'SEQUENCE'
+        ? 'GENERATED ALWAYS AS IDENTITY'
+        : undefined,
+    codecs: {
+        BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
+        BINARY: identity(),
+        BOOLEAN: identity(),
+        CITEXT: identity(),
+        DATE: { encode: (value) => value, decode: (value) => value instanceof Date ? value.toISOString().slice(0, 10) : value },
+        DATETIME: identity(),
+        DECIMAL: { encode: (value) => value, decode: (value) => Number(value) },
+        FLOAT: identity(),
+        INTEGER: { encode: (value) => value, decode: (value) => Number(value) },
+        JSON: identity(),
+        SEQUENCE: { encode: (value) => value, decode: (value) => Number(value) },
+        STRING: identity(),
+        TEXT: identity(),
+        UUID: identity(),
+    },
+};
+exports.dialect = dialect;
+class BunPostgres {
+    sql;
+    loggers;
+    inTransaction;
+    dialect = dialect;
+    constructor(sql, loggers = [], inTransaction = false) {
+        this.sql = sql;
+        this.loggers = loggers;
+        this.inTransaction = inTransaction;
+    }
+    async execute(sql, params) {
+        return await this.sql.unsafe(sql, params);
+    }
+    async transaction(fn) {
+        const callback = (tx) => fn(new BunPostgres(tx, this.loggers, true));
+        const result = this.inTransaction
+            ? this.sql.savepoint(callback)
+            : this.sql.begin(callback);
+        return await result;
+    }
+}
+const connect = (url, { loggers = [] } = {}) => new BunPostgres(new bun_1.SQL(url), loggers);
+exports.connect = connect;

package/dist/cjs/bun-sqlite.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialect = exports.connect = void 0;
+const bun_sqlite_1 = require("bun:sqlite");
+const TYPES = {
+    BIGINT: 'INTEGER',
+    BINARY: 'BLOB',
+    BOOLEAN: 'INTEGER',
+    CITEXT: 'TEXT COLLATE NOCASE',
+    DATE: 'TEXT',
+    DATETIME: 'INTEGER',
+    DECIMAL: 'NUMERIC',
+    FLOAT: 'REAL',
+    INTEGER: 'INTEGER',
+    JSON: 'TEXT',
+    SEQUENCE: 'INTEGER',
+    STRING: 'TEXT',
+    TEXT: 'TEXT',
+    UUID: 'TEXT',
+};
+const identity = () => ({
+    encode: (value) => value,
+    decode: (value) => value,
+});
+// integers are read as bigints (see `execute`), so those that aren't BIGINT
+// columns go back to being numbers
+const numeric = {
+    encode: (value) => value,
+    decode: (value) => Number(value),
+};
+const dialect = {
+    name: 'sqlite',
+    placeholder: () => '?',
+    type: (col) => TYPES[col.type],
+    generated: (col) => {
+        if (col.type === 'SEQUENCE' && col.primaryKey)
+            return 'AUTOINCREMENT';
+        if (col.type === 'SEQUENCE')
+            throw new Error(`SQLite can only generate sequences for primary keys, column "${col.name}" isn't one`);
+        return undefined;
+    },
+    codecs: {
+        BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
+        BINARY: identity(),
+        BOOLEAN: { encode: (value) => (value ? 1 : 0), decode: (value) => Number(value) === 1 },
+        CITEXT: identity(),
+        DATE: identity(),
+        DATETIME: { encode: (value) => value.getTime(), decode: (value) => new Date(Number(value)) },
+        DECIMAL: numeric,
+        FLOAT: numeric,
+        INTEGER: numeric,
+        JSON: { encode: (value) => JSON.stringify(value), decode: (value) => JSON.parse(value) },
+        SEQUENCE: numeric,
+        STRING: identity(),
+        TEXT: identity(),
+        UUID: identity(),
+    },
+};
+exports.dialect = dialect;
+class BunSQLite {
+    conn;
+    loggers;
+    depth;
+    dialect = dialect;
+    constructor(conn, loggers = [], depth = 0) {
+        this.conn = conn;
+        this.loggers = loggers;
+        this.depth = depth;
+    }
+    async execute(sql, params) {
+        // without safe integers, bun:sqlite rounds anything beyond 2^53
+        return this.conn.prepare(sql).safeIntegers(true).all(...params);
+    }
+    // bun:sqlite's own `transaction()` is synchronous and would commit before an
+    // async callback settles, hence the manual BEGIN/COMMIT (SAVEPOINT if nested)
+    async transaction(fn) {
+        const savepoint = `"sp_${this.depth}"`;
+        const [begin, commit, rollback] = this.depth === 0
+            ? ['BEGIN', 'COMMIT', 'ROLLBACK']
+            : [`SAVEPOINT ${savepoint}`, `RELEASE ${savepoint}`, `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}`];
+        this.conn.run(begin);
+        try {
+            const result = await fn(new BunSQLite(this.conn, this.loggers, this.depth + 1));
+            this.conn.run(commit);
+            return result;
+        }
+        catch (error) {
+            this.conn.run(rollback);
+            throw error;
+        }
+    }
+}
+const connect = (filename = ':memory:', { loggers = [] } = {}) => new BunSQLite(new bun_sqlite_1.Database(filename), loggers);
+exports.connect = connect;

package/dist/cjs/index.js

@@ -0,0 +1,453 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = exports.into = exports.from = exports.expr = exports.exec = exports.table = exports.defineMigrations = exports.create = exports.column = exports.ValidationError = void 0;
+const std = __importStar(require("./standard-schema"));
+const standard_schema_1 = require("./standard-schema");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return standard_schema_1.ValidationError; } });
+const utils_1 = require("./utils");
+class ColumnBuilder {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    default(value) {
+        return new ColumnBuilder({ ...this.props, default: value });
+    }
+    generated() {
+        if (this.props.type !== 'UUID')
+            throw new Error('Only UUID columns can be generated, use t.sequence() for integers');
+        return new ColumnBuilder({ ...this.props, generated: true });
+    }
+    nullable() {
+        if (this.props.primaryKey)
+            throw new Error('Cannot make a primary key column nullable');
+        return new ColumnBuilder({ ...this.props, nullable: true, schema: std.nullable(this.props.schema) });
+    }
+    primaryKey() {
+        if (this.props.nullable)
+            throw new Error('Cannot make a nullable column a primary key');
+        return new ColumnBuilder({ ...this.props, primaryKey: true });
+    }
+    unique() {
+        if (this.props.primaryKey)
+            throw new Error('Primary key columns are already unique');
+        return new ColumnBuilder({ ...this.props, unique: true });
+    }
+}
+const column = (props) => new ColumnBuilder(props);
+exports.column = column;
+const types = {
+    bigint: () => column({ type: 'BIGINT', schema: std.bigint() }),
+    binary: () => column({ type: 'BINARY', schema: std.instanceOf(Uint8Array) }),
+    boolean: () => column({ type: 'BOOLEAN', schema: std.boolean() }),
+    // case-insensitive text; postgres needs `CREATE EXTENSION citext` for it
+    citext: () => column({ type: 'CITEXT', schema: std.string() }),
+    date: () => column({ type: 'DATE', schema: std.isoDate() }),
+    datetime: () => column({ type: 'DATETIME', schema: std.date() }),
+    // `precision` and `scale` only shape postgres' NUMERIC; values are still
+    // numbers, so they're as exact as a double
+    decimal: (options) => column({ type: 'DECIMAL', schema: std.number(), ...options }),
+    enum: (values) => column({
+        type: 'STRING',
+        schema: std.enumOf(values),
+        length: Math.max(...values.map(value => value.length)),
+    }),
+    float: () => column({ type: 'FLOAT', schema: std.number() }),
+    integer: () => column({ type: 'INTEGER', schema: std.integer() }),
+    json: (schema) => column({ type: 'JSON', schema }),
+    sequence: () => column({ type: 'SEQUENCE', schema: std.integer(), generated: true }),
+    string: ({ size = 255 } = {}) => column({ type: 'STRING', schema: std.string({ max: size }), length: size }),
+    text: () => column({ type: 'TEXT', schema: std.string() }),
+    uuid: () => column({ type: 'UUID', schema: std.uuid() }),
+};
+exports.t = types;
+const defineTable = (name, shapeFn) => {
+    const columns = Object.fromEntries(Object
+        .entries(shapeFn(types))
+        .map(([key, { props }]) => [(0, utils_1.camelCase)(key), { ...props, key: (0, utils_1.camelCase)(key), name: (0, utils_1.snakeCase)((0, utils_1.camelCase)(key)) }]));
+    const aliased = (alias) => ({ name, alias, columns, as: aliased });
+    return aliased(name);
+};
+exports.table = defineTable;
+const columnOf = (table, key) => {
+    const col = table.columns[key];
+    if (!col)
+        throw new Error(`Unknown column "${key}" in table "${table.name}"`);
+    return col;
+};
+const quote = (ident) => `"${ident.replaceAll('"', '""')}"`;
+const ref = (col, qualifier) => qualifier
+    ? `${quote(qualifier)}.${quote(col.name)}`
+    : quote(col.name);
+class SqlBuilder {
+    dialect;
+    frags = [];
+    params = [];
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    push(...frags) {
+        this.frags.push(...frags);
+        return this;
+    }
+    param(value) {
+        this.params.push(value);
+        return this.push(this.dialect.placeholder(this.params.length));
+    }
+    join(items, separator, fn) {
+        items.forEach((item, i) => {
+            if (i > 0)
+                this.push(separator);
+            fn(item);
+        });
+        return this;
+    }
+    build() {
+        return { sql: this.frags.join(''), params: this.params };
+    }
+}
+const encode = (dialect, col, value) => value === null || value === undefined
+    ? null
+    : dialect.codecs[col.type].encode(value);
+const decode = (dialect, col, value) => value === null || value === undefined
+    ? null
+    : dialect.codecs[col.type].decode(value);
+const decoder = (dialect, cols) => (row) => Object.fromEntries(cols.map(col => [col.key, decode(dialect, col, row[col.key])]));
+const run = async (db, { sql, params }) => {
+    db.loggers.forEach(logger => logger.debug(sql, params));
+    try {
+        return await db.execute(sql, params);
+    }
+    catch (error) {
+        db.loggers.forEach(logger => logger.error(sql, params, error));
+        throw error;
+    }
+};
+// runs a raw statement, e.g. `CREATE EXTENSION` in a migration
+const exec = async (db, sql, params = []) => {
+    await run(db, { sql, params });
+};
+exports.exec = exec;
+const runReturning = async (db, b, table, returning) => {
+    if (returning === false) {
+        await run(db, b.build());
+        return undefined;
+    }
+    const cols = returning === true
+        ? Object.values(table.columns)
+        : returning.map(key => columnOf(table, key));
+    // an empty RETURNING isn't valid SQL, but it still takes one to know how
+    // many rows were affected
+    if (cols.length === 0) {
+        const rows = await run(db, b.push(' RETURNING 1').build());
+        return rows.map(() => ({}));
+    }
+    b.push(' RETURNING ').join(cols, ', ', col => b.push(ref(col), ' AS ', quote(col.key)));
+    const rows = await run(db, b.build());
+    return rows.map(decoder(db.dialect, cols));
+};
+const expr = Object.assign((key, op, value) => ({ key, op, value }), {
+    and: (exprs) => ({ group: 'AND', exprs }),
+    or: (exprs) => ({ group: 'OR', exprs }),
+});
+exports.expr = expr;
+const toCondition = (table, node) => 'group' in node
+    ? { group: node.group, conditions: node.exprs.map(expr => toCondition(table, expr)) }
+    : { col: columnOf(table, node.key), op: node.op, value: node.value };
+const renderCondition = (b, qualifier) => (condition) => {
+    if ('group' in condition) {
+        const { group, conditions } = condition;
+        if (conditions.length === 0)
+            return b.push(group === 'AND' ? '1 = 1' : '1 = 0');
+        return b.push('(').join(conditions, ` ${group} `, renderCondition(b, qualifier)).push(')');
+    }
+    const { col, op, value } = condition;
+    if (op === 'is' || op === 'is not')
+        return b.push(ref(col, qualifier), ' ', op.toUpperCase(), ' NULL');
+    if (op !== 'in' && op !== 'not in')
+        return b.push(ref(col, qualifier), ' ', op.toUpperCase(), ' ').param(encode(b.dialect, col, value));
+    const values = value;
+    if (values.length === 0)
+        return b.push(op === 'in' ? '1 = 0' : '1 = 1');
+    return b
+        .push(ref(col, qualifier), ' ', op.toUpperCase(), ' (')
+        .join(values, ', ', v => b.param(encode(b.dialect, col, v)))
+        .push(')');
+};
+const renderWhere = (b, conditions, qualifier) => conditions.length === 0
+    ? b
+    : b.push(' WHERE ').join(conditions, ' AND ', renderCondition(b, qualifier));
+const parseChanges = (table, { set = {}, inc = {}, replace = [] }) => {
+    const updatable = Object.values(table.columns).filter(col => !col.generated && !col.primaryKey);
+    const numeric = updatable.filter(col => ['BIGINT', 'DECIMAL', 'FLOAT', 'INTEGER'].includes(col.type));
+    const sets = std.parseOrThrow(std.strictObject(Object.fromEntries(updatable.map(col => [col.key, std.optional(col.schema)]))), set);
+    const incs = std.parseOrThrow(std.strictObject(Object.fromEntries(numeric.map(col => [col.key, std.optional(std.number())]))), inc);
+    const replaced = replace.map(key => {
+        const col = updatable.find(col => col.key === key);
+        if (!col)
+            throw new Error(`Cannot replace "${key}": it's not an updatable field of "${table.name}"`);
+        return col;
+    });
+    return [
+        ...Object.entries(sets).filter(([, value]) => value !== undefined).map(([key, value]) => ({ col: columnOf(table, key), op: 'set', value })),
+        ...Object.entries(incs).filter(([, value]) => value !== undefined).map(([key, value]) => ({ col: columnOf(table, key), op: 'inc', value })),
+        ...replaced.map(col => ({ col, op: 'replace' })),
+    ];
+};
+// on conflict, `qualifier` tells the row's current value apart from EXCLUDED's
+const renderAssignments = (b, assignments, qualifier) => b
+    .join(assignments, ', ', ({ col, op, value }) => {
+    if (op === 'replace')
+        return b.push(ref(col), ' = EXCLUDED.', quote(col.name));
+    if (op === 'inc')
+        return b.push(ref(col), ' = ', ref(col, qualifier), ' + ').param(value);
+    return b.push(ref(col), ' = ').param(encode(b.dialect, col, value));
+});
+const CLIENT_GENERATORS = {
+    UUID: () => Bun.randomUUIDv7(),
+};
+const isGeneratedByClient = (dialect, col) => col.generated === true && dialect.generated(col) === undefined;
+const resolveInsertValue = (col, row) => {
+    if (col.generated) {
+        const generate = CLIENT_GENERATORS[col.type];
+        if (!generate)
+            throw new Error(`Cannot generate a value for column "${col.name}" client-side`);
+        return generate();
+    }
+    if (row[col.key] !== undefined)
+        return row[col.key];
+    if ('default' in col)
+        return typeof col.default === 'function' ? col.default() : col.default;
+    if (col.nullable)
+        return null;
+    return undefined;
+};
+class InsertBuilder {
+    table;
+    rows;
+    constructor(table, rows = []) {
+        this.table = table;
+        this.rows = rows;
+    }
+    values(rows) {
+        return new InsertBuilder(this.table, [...this.rows, ...(0, utils_1.wrap)(rows)]);
+    }
+    async insert(db, { returning = true, conflict } = {}) {
+        if (this.rows.length === 0)
+            return returning === false ? undefined : [];
+        const cols = Object.values(this.table.columns);
+        const insertable = cols.filter(col => !col.generated || isGeneratedByClient(db.dialect, col));
+        const schema = std.array(std.strictObject(Object.fromEntries(insertable.map(col => [col.key, col.schema]))));
+        const rows = std.parseOrThrow(schema, this.rows.map(row => ({
+            ...row,
+            ...Object.fromEntries(insertable.map(col => [col.key, resolveInsertValue(col, row)])),
+        })));
+        const b = new SqlBuilder(db.dialect)
+            .push('INSERT INTO ', quote(this.table.name), ' (', insertable.map(col => quote(col.name)).join(', '), ') VALUES ');
+        b.join(rows, ', ', row => b
+            .push('(')
+            .join(insertable, ', ', col => b.param(encode(db.dialect, col, row[col.key])))
+            .push(')'));
+        if (conflict)
+            this.renderConflict(b, conflict);
+        return await runReturning(db, b, this.table, returning);
+    }
+    renderConflict(b, conflict) {
+        if (conflict.do === 'throw')
+            return b;
+        b.push(' ON CONFLICT');
+        if (conflict.on.length > 0)
+            b.push(' (', conflict.on.map(key => quote(columnOf(this.table, key).name)).join(', '), ')');
+        if (conflict.do === 'nothing')
+            return b.push(' DO NOTHING');
+        const assignments = parseChanges(this.table, conflict.do);
+        if (assignments.length === 0)
+            throw new Error('Nothing to update on conflict: `set`, `inc` and `replace` are empty');
+        return renderAssignments(b.push(' DO UPDATE SET '), assignments, this.table.name);
+    }
+}
+const into = (table) => new InsertBuilder(table);
+exports.into = into;
+// `S` holds the selected fields, every field unless `select` says otherwise
+class QueryBuilder {
+    query;
+    constructor(query) {
+        this.query = query;
+    }
+    select(keys) {
+        return new QueryBuilder({ ...this.query, select: keys });
+    }
+    where(...args) {
+        const node = args.length === 1 ? args[0] : { key: args[0], op: args[1], value: args[2] };
+        return new QueryBuilder({ ...this.query, where: [...this.query.where, toCondition(this.query.table, node)] });
+    }
+    orderBy(keys) {
+        const orderBy = keys.map(key => typeof key === 'string'
+            ? [columnOf(this.query.table, key), 'ASC']
+            : [columnOf(this.query.table, key[0]), key[1]]);
+        return new QueryBuilder({ ...this.query, orderBy: [...this.query.orderBy, ...orderBy] });
+    }
+    limit(n) {
+        return new QueryBuilder({ ...this.query, limit: n });
+    }
+    offset(n) {
+        return new QueryBuilder({ ...this.query, offset: n });
+    }
+    async all(db) {
+        const { table, select } = this.query;
+        const cols = select
+            ? select.map(key => columnOf(table, key))
+            : Object.values(table.columns);
+        const rows = await run(db, this.renderSelect(new SqlBuilder(db.dialect), cols).build());
+        return rows.map(decoder(db.dialect, cols));
+    }
+    async one(db) {
+        const [row] = await this.top().all(db);
+        return row ?? null;
+    }
+    async exists(db) {
+        const rows = await this.top().select([]).all(db);
+        return rows.length > 0;
+    }
+    // counts the rows `select` would return: as a subquery, limit and offset
+    // still apply, and postgres doesn't take ORDER BY next to a bare COUNT(*)
+    async count(db) {
+        const b = new SqlBuilder(db.dialect).push('SELECT COUNT(*) AS "count" FROM (');
+        const [row] = await run(db, this.renderSelect(b, []).push(') AS "q"').build());
+        // postgres returns COUNT(*) as a bigint
+        return Number(row['count']);
+    }
+    async update(db, { returning = true, ...changes }) {
+        this.assertUnbounded('update');
+        const { table, where } = this.query;
+        const assignments = parseChanges(table, changes);
+        if (assignments.length === 0)
+            throw new Error('Nothing to update: both `set` and `inc` are empty');
+        const b = new SqlBuilder(db.dialect).push('UPDATE ', quote(table.name), ' SET ');
+        renderAssignments(b, assignments);
+        renderWhere(b, where);
+        return await runReturning(db, b, table, returning);
+    }
+    async delete(db, { returning = false } = {}) {
+        this.assertUnbounded('delete');
+        const { table, where } = this.query;
+        const b = new SqlBuilder(db.dialect).push('DELETE FROM ', quote(table.name));
+        renderWhere(b, where);
+        return await runReturning(db, b, table, returning);
+    }
+    renderSelect(b, cols) {
+        const { table, where, orderBy, limit, offset } = this.query;
+        b.push('SELECT ');
+        // an empty select list isn't valid SQL, but each matching row still needs
+        // an (empty) object
+        if (cols.length === 0)
+            b.push('1');
+        else
+            b.join(cols, ', ', col => b.push(ref(col, table.alias), ' AS ', quote(col.key)));
+        b.push(' FROM ', quote(table.name), ' AS ', quote(table.alias));
+        renderWhere(b, where, table.alias);
+        if (orderBy.length > 0)
+            b.push(' ORDER BY ').join(orderBy, ', ', ([col, dir]) => b.push(ref(col, table.alias), ' ', dir));
+        // sqlite requires LIMIT whenever there's an OFFSET, and there's no "no
+        // limit" value both sqlite and postgres accept other than a huge number
+        if (limit !== undefined || offset !== undefined)
+            b.push(' LIMIT ').param(limit ?? Number.MAX_SAFE_INTEGER);
+        if (offset !== undefined)
+            b.push(' OFFSET ').param(offset);
+        return b;
+    }
+    // keeps a `limit(0)`, which can never match
+    top() {
+        return this.limit(Math.min(this.query.limit ?? 1, 1));
+    }
+    // UPDATE/DELETE ... ORDER BY/LIMIT isn't portable, so refuse it rather than
+    // silently affecting more rows than the query suggests
+    assertUnbounded(operation) {
+        const { orderBy, limit, offset } = this.query;
+        if (orderBy.length > 0 || limit !== undefined || offset !== undefined) {
+            throw new Error(`Cannot ${operation} with orderBy, limit or offset`);
+        }
+    }
+}
+const from = (table) => new QueryBuilder({ table, where: [], orderBy: [] });
+exports.from = from;
+// ─── ddl ─────────────────────────────────────────────────────────────────────
+const renderColumnDefinition = (dialect, col) => [
+    quote(col.name),
+    dialect.type(col),
+    col.primaryKey && 'PRIMARY KEY',
+    col.generated && dialect.generated(col),
+    !col.nullable && 'NOT NULL',
+    col.unique && 'UNIQUE',
+].filter(Boolean).join(' ');
+const createIndex = (table, keys, { ifNotExists = false, name, unique = false, } = {}) => ({
+    onto: async (db) => {
+        const cols = keys.map(key => columnOf(table, key).name);
+        const index = name ?? `${table.name}_${cols.join('_')}_index`;
+        const sql = `CREATE ${unique ? 'UNIQUE ' : ''}INDEX ${ifNotExists ? 'IF NOT EXISTS ' : ''}${quote(index)} ON ${quote(table.name)} (${cols.map(quote).join(', ')})`;
+        await run(db, { sql, params: [] });
+    },
+});
+const create = {
+    table: (table, { ifNotExists = false } = {}) => ({
+        onto: async (db) => {
+            const cols = Object.values(table.columns).map(col => renderColumnDefinition(db.dialect, col));
+            const sql = `CREATE TABLE ${ifNotExists ? 'IF NOT EXISTS ' : ''}${quote(table.name)} (${cols.join(', ')})`;
+            await run(db, { sql, params: [] });
+        },
+    }),
+    index: createIndex,
+    uniqueIndex: (table, keys, options = {}) => createIndex(table, keys, { ...options, unique: true }),
+};
+exports.create = create;
+// ─── migrations ──────────────────────────────────────────────────────────────
+const schemaMigrations = defineTable('schema_migrations', t => ({
+    id: t.string().primaryKey(),
+    migratedAt: t.datetime(),
+}));
+const defineMigrations = (migrations) => async (db) => {
+    await create.table(schemaMigrations, { ifNotExists: true }).onto(db);
+    const applied = new Set((await from(schemaMigrations).select(['id']).all(db)).map(row => row.id));
+    for (const id of Object.keys(migrations).sort()) {
+        if (applied.has(id))
+            continue;
+        await db.transaction(async (tx) => {
+            await migrations[id](tx);
+            await into(schemaMigrations).values({ id, migratedAt: new Date() }).insert(tx);
+        });
+    }
+};
+exports.defineMigrations = defineMigrations;