@rwillians/exto 0.1.0 → 0.1.2

package/dist/esm/index.js

@@ -0,0 +1,408 @@
+import * as std from './standard-schema';
+import { ValidationError } from './standard-schema';
+import { camelCase, snakeCase, wrap } from './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);
+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() }),
+};
+const defineTable = (name, shapeFn) => {
+    const columns = Object.fromEntries(Object
+        .entries(shapeFn(types))
+        .map(([key, { props }]) => [camelCase(key), { ...props, key: camelCase(key), name: snakeCase(camelCase(key)) }]));
+    const aliased = (alias) => ({ name, alias, columns, as: aliased });
+    return aliased(name);
+};
+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 });
+};
+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 }),
+});
+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, ...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);
+// `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: [] });
+// ─── 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 }),
+};
+// ─── 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);
+        });
+    }
+};
+export { ValidationError, column, create, defineMigrations, defineTable as table, exec, expr, from, into, types as t, };

package/dist/esm/standard-schema.js

@@ -0,0 +1,229 @@
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                       STANDARD SCHEMA SPEC                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                        STANDARD SCHEMA API                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export {};
+/**
+ * @public  Thrown when a value fails validation, carrying every issue found.
+ * @since   0.1.0
+ * @version 1
+ */
+export class ValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super('Failed validation:\n' + issues.map(issue => `  - ${formatPath(issue.path)}${issue.message}`).join('\n'));
+        this.issues = issues;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+export const parse = (schema, value) => {
+    const parsed = schema['~standard'].validate(value);
+    if (parsed instanceof Promise) {
+        throw new Error('async standard schema validators are not supported');
+    }
+    return parsed;
+};
+/**
+ * @public  Like {@link parse}, but returns the value or throws a
+ *          {@link ValidationError}.
+ * @since   0.1.0
+ * @version 1
+ */
+export const parseOrThrow = (schema, value) => {
+    const parsed = parse(schema, value);
+    if (parsed.issues)
+        throw new ValidationError(parsed.issues);
+    return parsed.value;
+};
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                               UTILS                               //
+// // // // // // // // // // // // // // // // // // // // // // // //
+const formatPath = (path) => path && path.length > 0
+    ? path.map(segment => String(typeof segment === 'object' ? segment.key : segment)).join('.') + ': '
+    : '';
+const prependPath = (path) => (issue) => ({
+    ...issue,
+    path: [path, ...(issue.path ?? [])],
+});
+const define = (validate) => ({
+    '~standard': { version: 1, vendor: 'exto', validate },
+});
+const fail = (message) => ({ issues: [{ message }] });
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                        BUILT-IN VALIDATORS                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export const array = (schema) => define((input) => {
+    if (!Array.isArray(input))
+        return fail('must be an array');
+    const issues = [];
+    const value = [];
+    input.forEach((item, i) => {
+        const parsed = parse(schema, item);
+        if (parsed.issues)
+            issues.push(...parsed.issues.map(prependPath(i)));
+        else
+            value.push(parsed.value);
+    });
+    return issues.length > 0
+        ? { issues }
+        : { value };
+});
+/**
+ * @public  Defines a standard schema for bigints.
+ * @since   0.1.0
+ * @version 1
+ */
+export const bigint = () => define((input) => typeof input === 'bigint'
+    ? { value: input }
+    : fail('must be a bigint'));
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export const boolean = () => define((input) => typeof input === 'boolean'
+    ? { value: input }
+    : fail('must be a boolean'));
+/**
+ * @public  Defines a standard schema for dates, coercing ISO 8601 strings
+ *          and epoch timestamps (in milliseconds) into `Date`.
+ * @since   0.1.0
+ * @version 1
+ */
+export const date = () => define((input) => {
+    const value = input instanceof Date ? input
+        : typeof input === 'string' || typeof input === 'number' ? new Date(input)
+            : undefined;
+    return value && !Number.isNaN(value.getTime())
+        ? { value }
+        : fail('must be a valid date, ISO 8601 string or epoch timestamp in milliseconds');
+});
+/**
+ * @public  Defines a standard schema for one of the given string values.
+ * @since   0.1.0
+ * @version 1
+ */
+export const enumOf = (values) => define((input) => values.includes(input)
+    ? { value: input }
+    : fail(`must be one of: ${values.join(', ')}`));
+/**
+ * @public  Defines a standard schema for instances of a given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export const instanceOf = (ctor) => define((input) => input instanceof ctor
+    ? { value: input }
+    : fail(`must be an instance of ${ctor.name}`));
+/**
+ * @public  Defines a standard schema for integers, within the safe integer
+ *          range by default.
+ * @since   0.1.0
+ * @version 1
+ */
+export const integer = ({ min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER } = {}) => define((input) => {
+    if (!Number.isInteger(input))
+        return fail('must be an integer');
+    if (input < min)
+        return fail(`must be greater than or equal to ${min}`);
+    if (input > max)
+        return fail(`must be less than or equal to ${max}`);
+    return { value: input };
+});
+/**
+ * @public  Defines a standard schema for calendar dates as `YYYY-MM-DD`
+ *          strings.
+ * @since   0.1.0
+ * @version 1
+ */
+export const isoDate = () => define((input) => {
+    const valid = typeof input === 'string'
+        && /^\d{4}-\d{2}-\d{2}$/.test(input)
+        && new Date(`${input}T00:00:00Z`).toISOString().startsWith(input);
+    return valid
+        ? { value: input }
+        : fail('must be a valid date in the YYYY-MM-DD format');
+});
+/**
+ * @public  Makes a given standard schema accept `null`.
+ * @since   0.1.0
+ * @version 1
+ */
+export const nullable = (schema) => define((input) => input === null
+    ? { value: null }
+    : parse(schema, input));
+/**
+ * @public  Defines a standard schema for finite numbers.
+ * @since   0.1.0
+ * @version 1
+ */
+export const number = () => define((input) => Number.isFinite(input)
+    ? { value: input }
+    : fail('must be a finite number'));
+/**
+ * @public  Makes a given standard schema accept `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+export const optional = (schema) => define((input) => input === undefined
+    ? { value: undefined }
+    : parse(schema, input));
+/**
+ * @public  Defines a standard schema for strings, optionally limited in
+ *          length.
+ * @since   0.1.0
+ * @version 1
+ */
+export const string = ({ max } = {}) => define((input) => {
+    if (typeof input !== 'string')
+        return fail('must be a string');
+    if (max !== undefined && input.length > max)
+        return fail(`must be at most ${max} characters long`);
+    return { value: input };
+});
+export const strictObject = (shape) => define((input) => {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        return fail('must be an object');
+    const record = input;
+    const issues = Object
+        .keys(record)
+        .filter(key => !(key in shape))
+        .map(key => ({ path: [key], message: 'unknown field' }));
+    const value = {};
+    for (const [key, schema] of Object.entries(shape)) {
+        const parsed = parse(schema, record[key]);
+        if (parsed.issues && record[key] === undefined)
+            issues.push({ path: [key], message: 'is required' });
+        else if (parsed.issues)
+            issues.push(...parsed.issues.map(prependPath(key)));
+        else if (parsed.value !== undefined)
+            value[key] = parsed.value;
+    }
+    return issues.length > 0
+        ? { issues }
+        : { value: value };
+});
+/**
+ * @public  Defines a standard schema for UUID strings (any version).
+ * @since   0.1.0
+ * @version 1
+ */
+export const uuid = () => define((input) => typeof input === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input)
+    ? { value: input }
+    : fail('must be a valid UUID'));

package/dist/esm/utils.js

@@ -0,0 +1,10 @@
+export const camelCase = (str) => str.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+export const snakeCase = (str) => str.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+export const wrap = (value) => Array.isArray(value)
+    ? value
+    : [value];
+export function raise(ctorOrMessage, messageOrCause, cause) {
+    if (typeof ctorOrMessage === 'string')
+        throw new Error(ctorOrMessage, { cause: messageOrCause });
+    throw new ctorOrMessage(messageOrCause, { cause });
+}

package/dist/types/bun-postgres.d.ts

@@ -0,0 +1,16 @@
+import { SQL } from 'bun';
+import type { Dialect, IDatabase, ILogger, Row } from './index';
+declare const dialect: Dialect;
+declare class BunPostgres implements IDatabase {
+    private readonly sql;
+    readonly loggers: ILogger[];
+    private readonly inTransaction;
+    readonly dialect: Dialect;
+    constructor(sql: SQL, loggers?: ILogger[], inTransaction?: boolean);
+    execute(sql: string, params: unknown[]): Promise<Row[] & SQL.ResultMetadata>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const connect: (url: string, { loggers }?: {
+    loggers?: ILogger[];
+}) => BunPostgres;
+export { connect, dialect, };

package/dist/types/bun-sqlite.d.ts

@@ -0,0 +1,16 @@
+import { Database } from 'bun:sqlite';
+import type { Dialect, IDatabase, ILogger, Row } from './index';
+declare const dialect: Dialect;
+declare class BunSQLite implements IDatabase {
+    private readonly conn;
+    readonly loggers: ILogger[];
+    private readonly depth;
+    readonly dialect: Dialect;
+    constructor(conn: Database, loggers?: ILogger[], depth?: number);
+    execute(sql: string, params: unknown[]): Promise<Row[]>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const connect: (filename?: string, { loggers }?: {
+    loggers?: ILogger[];
+}) => BunSQLite;
+export { connect, dialect, };