@rwillians/exto 0.1.1 → 0.2.0

package/dist/types/index.d.ts

@@ -0,0 +1,438 @@
+import * as std from './standard-schema';
+import { ValidationError } from './standard-schema';
+import { type Expand } from './utils';
+type Primitive = 'BIGINT' | 'BINARY' | 'BOOLEAN' | 'CITEXT' | 'DATE' | 'DECIMAL' | 'FLOAT' | 'INTEGER' | 'JSON' | 'SEQUENCE' | 'STRING' | 'TEXT' | 'TIMESTAMP' | 'UUID';
+type NumericType = 'BIGINT' | 'DECIMAL' | 'FLOAT' | 'INTEGER' | 'SEQUENCE';
+type ColumnProps<S extends std.Schema = std.Schema> = {
+    type: Primitive;
+    schema: S;
+    default?: unknown;
+    generated?: true;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    nullable?: true;
+    primaryKey?: true;
+    unique?: true;
+    fields?: Columns;
+    many?: true;
+};
+type Column<K extends string = string, P extends ColumnProps = ColumnProps> = P & {
+    key: K;
+    name: string;
+    input: std.input<P['schema']>;
+    output: std.output<P['schema']>;
+};
+type Columns = Record<string, Column>;
+declare class ColumnBuilder<P extends ColumnProps> {
+    readonly props: P;
+    constructor(props: P);
+    default(value: std.output<P['schema']> | (() => std.output<P['schema']>)): ColumnBuilder<Expand<P & {
+        default: typeof value;
+    }>>;
+    generated(): ColumnBuilder<Expand<P & {
+        generated: true;
+    }>>;
+    optional(): ColumnBuilder<Expand<Omit<P, "schema"> & {
+        nullable: true;
+        schema: std.Schema<std.input<P['schema']> | null, std.output<P['schema']> | null>;
+    }>>;
+    primaryKey(): ColumnBuilder<Expand<P & {
+        primaryKey: true;
+    }>>;
+    unique(): ColumnBuilder<Expand<P & {
+        unique: true;
+    }>>;
+    unsigned(this: ColumnBuilder<P & {
+        type: 'INTEGER';
+    }>): ColumnBuilder<P>;
+}
+declare const column: <P extends ColumnProps>(props: P) => ColumnBuilder<P>;
+type Shape = Record<string, ColumnBuilder<ColumnProps>>;
+type ColumnsOfShape<S extends Shape> = {
+    [K in keyof S & string]: Column<K, S[K]['props']>;
+};
+declare const embedded: {
+    one: <S extends Shape>(shape: S) => ColumnBuilder<{
+        type: "JSON";
+        schema: std.Schema<Expand<(ColumnsOfShape<S> extends infer T_3 extends Columns ? { [K in keyof T_3 as ColumnsOfShape<S>[K] extends OmitOnInsert | OptionalOnInsert ? never : K]: T_3[K]["input"]; } : never) & (ColumnsOfShape<S> extends infer T_4 extends Columns ? { [K in keyof T_4 as ColumnsOfShape<S>[K] extends OmitOnInsert ? never : ColumnsOfShape<S>[K] extends OptionalOnInsert ? K : never]?: T_4[K]["input"] | undefined; } : never)>, Expand<ColumnsOfShape<S> extends infer T_5 extends Columns ? { [K in keyof T_5]: T_5[K]["output"]; } : never>>;
+        fields: ColumnsOfShape<S>;
+    }>;
+    many: <S extends Shape>(shape: S) => ColumnBuilder<{
+        type: "JSON";
+        schema: std.Schema<Expand<(ColumnsOfShape<S> extends infer T extends Columns ? { [K in keyof T as ColumnsOfShape<S>[K] extends OmitOnInsert | OptionalOnInsert ? never : K]: T[K]["input"]; } : never) & (ColumnsOfShape<S> extends infer T_1 extends Columns ? { [K in keyof T_1 as ColumnsOfShape<S>[K] extends OmitOnInsert ? never : ColumnsOfShape<S>[K] extends OptionalOnInsert ? K : never]?: T_1[K]["input"] | undefined; } : never)>[], Expand<ColumnsOfShape<S> extends infer T_2 extends Columns ? { [K in keyof T_2]: T_2[K]["output"]; } : never>[]>;
+        fields: ColumnsOfShape<S>;
+        many: true;
+    }>;
+};
+declare const defineType: <S extends std.Schema>({ primitive, schema }: {
+    primitive: Exclude<Primitive, 'JSON'>;
+    schema: S;
+}) => ColumnBuilder<{
+    type: "BIGINT" | "BINARY" | "BOOLEAN" | "CITEXT" | "DATE" | "DECIMAL" | "FLOAT" | "INTEGER" | "SEQUENCE" | "STRING" | "TEXT" | "TIMESTAMP" | "UUID";
+    schema: S;
+}>;
+declare const types: {
+    bigint: () => ColumnBuilder<{
+        type: "BIGINT";
+        schema: std.Schema<bigint, bigint>;
+    }>;
+    binary: () => ColumnBuilder<{
+        type: "BINARY";
+        schema: std.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    }>;
+    boolean: () => ColumnBuilder<{
+        type: "BOOLEAN";
+        schema: std.Schema<boolean, boolean>;
+    }>;
+    citext: () => ColumnBuilder<{
+        type: "CITEXT";
+        schema: std.Schema<string, string>;
+    }>;
+    date: () => ColumnBuilder<{
+        type: "DATE";
+        schema: std.Schema<string, string>;
+    }>;
+    decimal: (options?: {
+        precision: number;
+        scale: number;
+    }) => ColumnBuilder<{
+        precision?: number | undefined;
+        scale?: number | undefined;
+        type: "DECIMAL";
+        schema: std.Schema<number, number>;
+    }>;
+    enum: <const T extends readonly [string, ...string[]]>(values: T) => ColumnBuilder<{
+        type: "STRING";
+        schema: std.Schema<T[number], T[number]>;
+        length: number;
+    }>;
+    float: () => ColumnBuilder<{
+        type: "FLOAT";
+        schema: std.Schema<number, number>;
+    }>;
+    integer: () => ColumnBuilder<{
+        type: "INTEGER";
+        schema: std.Schema<number, number>;
+    }>;
+    json: <S extends std.Schema>(schema: S) => ColumnBuilder<{
+        type: "JSON";
+        schema: S;
+    }>;
+    record: () => ColumnBuilder<{
+        type: "JSON";
+        schema: std.Schema<Record<string, unknown>, Record<string, unknown>>;
+    }>;
+    sequence: () => ColumnBuilder<{
+        type: "SEQUENCE";
+        schema: std.Schema<number, number>;
+        generated: true;
+    }>;
+    string: ({ size }?: {
+        size?: number;
+    }) => ColumnBuilder<{
+        type: "STRING";
+        schema: std.Schema<string, string>;
+        length: number;
+    }>;
+    text: () => ColumnBuilder<{
+        type: "TEXT";
+        schema: std.Schema<string, string>;
+    }>;
+    timestamp: () => ColumnBuilder<{
+        type: "TIMESTAMP";
+        schema: std.Schema<string | number | Date, Date>;
+    }>;
+    uuidv7: () => ColumnBuilder<{
+        type: "UUID";
+        schema: std.Schema<string, string>;
+    }>;
+};
+declare const NAME: unique symbol;
+declare const ALIAS: unique symbol;
+declare const NODE: unique symbol;
+declare const COLUMNS: unique symbol;
+declare const OPERAND: unique symbol;
+declare const KEY: unique symbol;
+type Op = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'is' | 'is not';
+type Node = {
+    kind: 'ref';
+    alias: string;
+    col: Column;
+    path: Column[];
+} | {
+    kind: 'fragment';
+    strings: readonly string[];
+    values: unknown[];
+} | {
+    kind: 'call';
+    fn: 'COUNT' | 'SUM';
+    arg: Node;
+} | {
+    kind: 'compare';
+    lhs: Node;
+    op: Op;
+    rhs: Node | {
+        kind: 'value';
+        value: unknown;
+    };
+} | {
+    kind: 'group';
+    op: 'AND' | 'OR';
+    nodes: Node[];
+};
+type Operand<A extends string = string, V = unknown, N extends string = string> = {
+    readonly [NODE]: Node;
+    readonly [OPERAND]: {
+        aliases: A;
+        value: V;
+        nulls: N;
+    };
+};
+type ColumnRef<A extends string = string, K extends string = string, V = unknown> = Operand<A, V, A> & {
+    readonly [KEY]: K;
+};
+type FieldRefs<A extends string, C extends Column> = C extends {
+    fields: infer F extends Columns;
+} ? C extends {
+    many: true;
+} ? {} : {
+    readonly [K in keyof F & string]: Operand<A, F[K]['output'], A> & FieldRefs<A, F[K]>;
+} : {};
+type RefTo<A extends string, K extends string, C extends Column> = ColumnRef<A, K, C['output']> & FieldRefs<A, C>;
+type Table<N extends string = string, A extends string = string, C extends Columns = Columns> = {
+    readonly [NAME]: N;
+    readonly [ALIAS]: A;
+    readonly [COLUMNS]: C;
+};
+type ColumnsOf<T extends Table> = T[typeof COLUMNS];
+type AliasOf<T extends Table> = T[typeof ALIAS];
+type Keys<T extends Table> = keyof ColumnsOf<T> & string;
+type OmitOnInsert = {
+    generated: true;
+};
+type OptionalOnInsert = {
+    default: unknown;
+} | {
+    nullable: true;
+};
+type OmitOnUpdate = {
+    generated: true;
+} | {
+    primaryKey: true;
+};
+type InferForSelect<C extends Columns> = Expand<{
+    [K in keyof C]: C[K]['output'];
+}>;
+type InferForInsert<C extends Columns> = Expand<{
+    [K in keyof C as C[K] extends OmitOnInsert | OptionalOnInsert ? never : K]: C[K]['input'];
+} & {
+    [K in keyof C as C[K] extends OmitOnInsert ? never : C[K] extends OptionalOnInsert ? K : never]?: C[K]['input'];
+}>;
+type InferForUpdate<C extends Columns> = Expand<{
+    [K in keyof C as C[K] extends OmitOnUpdate ? never : K]?: C[K]['input'];
+}>;
+type Infer<M extends 'select' | 'insert' | 'update', T extends Table> = {
+    select: InferForSelect<ColumnsOf<T>>;
+    insert: InferForInsert<ColumnsOf<T>>;
+    update: InferForUpdate<ColumnsOf<T>>;
+}[M];
+type NumericKeys<C extends Columns> = {
+    [K in keyof C]: C[K] extends OmitOnUpdate ? never : C[K]['type'] extends NumericType ? K : never;
+}[keyof C];
+declare class Aliasable<N extends string, C extends Columns> {
+    as<B extends string>(alias: B): DefinedTable<N, B, C>;
+}
+type DefinedTable<N extends string, A extends string, C extends Columns> = Table<N, A, C> & {
+    readonly [K in keyof C & string]: RefTo<A, K, C[K]>;
+} & Aliasable<N, C>;
+declare const RESERVED: readonly ['as'];
+type Reserved<S> = {
+    [K in keyof S & typeof RESERVED[number]]: never;
+};
+declare const defineTable: <N extends string, S extends Shape>(name: N, shape: S & NoInfer<Reserved<S>>) => DefinedTable<N, N, ColumnsOfShape<S>>;
+declare const parse: <T extends Table>(table: T, input: unknown) => Infer<'insert', T>;
+type Codec = {
+    encode: (value: any) => unknown;
+    decode: (value: any) => unknown;
+};
+type DialectName = 'postgres' | 'sqlite' | (string & {});
+/**
+ * Everything that differs between database engines. SQL generation, param
+ * collection, validation and encoding/decoding all live in the core.
+ *
+ * `generated` returns the DDL that makes the database generate the column's
+ * value, or `undefined` when the database can't natively, in which case the
+ * value is generated client-side on insert.
+ *
+ * `json` extracts a field nested in a JSON column, as an SQL value of the
+ * field's type: a JSON document itself when the field is a JSON one (a
+ * record, or embedded fields).
+ */
+interface Dialect {
+    name: DialectName;
+    placeholder(index: number): string;
+    type(column: Column): string;
+    generated(column: Column): string | undefined;
+    json(sql: string, path: string[], type: Primitive): string;
+    codecs: Record<Primitive, Codec>;
+}
+interface ILogger {
+    debug(sql: string, params: unknown[]): void;
+    error(sql: string, params: unknown[], error: unknown): void;
+}
+type Row = Record<string, unknown>;
+interface IDatabase {
+    readonly dialect: Dialect;
+    readonly loggers: ILogger[];
+    execute(sql: string, params: unknown[]): Promise<Row[]>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const exec: (db: IDatabase, sql: string, params?: unknown[]) => Promise<void>;
+type ValueOf<O> = O extends {
+    readonly [OPERAND]: {
+        value: infer V;
+    };
+} ? V : never;
+type AliasesOf<O> = O extends {
+    readonly [OPERAND]: {
+        aliases: infer A extends string;
+    };
+} ? A : never;
+type NullsOf<O> = O extends {
+    readonly [OPERAND]: {
+        nulls: infer N extends string;
+    };
+} ? N : never;
+type ValueIn<O, N extends string> = [NullsOf<O> & N] extends [never] ? ValueOf<O> : ValueOf<O> | null;
+type ComparisonOp = '=' | '!=' | '<' | '<=' | '>' | '>=';
+type ValueFor<V, O extends Op> = O extends 'is' | 'is not' ? null extends V ? null : never : NonNullable<V>;
+type RhsFor<V, O extends Op, A extends string = string> = ValueFor<V, O> | (O extends ComparisonOp ? Operand<A, NonNullable<V> | null> : never);
+type Condition<A extends string = string> = Operand<A, boolean, never>;
+type ExprOf = {
+    <L extends Operand, O extends Op>(lhs: L, op: O, rhs: ValueFor<ValueOf<L>, O>): Condition<AliasesOf<L>>;
+    <L extends Operand, O extends ComparisonOp, R extends Operand<string, NonNullable<ValueOf<L>> | null>>(lhs: L, op: O, rhs: R): Condition<AliasesOf<L> | AliasesOf<R>>;
+};
+declare const expr: ExprOf & {
+    and: <E extends Condition>(exprs: E[]) => Condition<AliasesOf<E>>;
+    or: <E extends Condition>(exprs: E[]) => Condition<AliasesOf<E>>;
+    count: <O extends Operand>(arg: O) => Operand<AliasesOf<O>, number, never>;
+    sum: <O extends Operand<string, number | null>>(arg: O) => Operand<AliasesOf<O>, number, never>;
+};
+declare const f: <V extends unknown[]>(strings: TemplateStringsArray, ...values: V) => Operand<AliasesOf<V[number]>, unknown, never>;
+type Scope = Map<string, Table>;
+type Returnable<T extends Table> = Keys<T> | ColumnRef<AliasOf<T>, Keys<T>>;
+type ReturnedKey<R> = R extends string ? R : R extends {
+    readonly [KEY]: infer K extends string;
+} ? K : never;
+type Returned<T extends Table, R> = Pick<InferForSelect<ColumnsOf<T>>, ReturnedKey<R> & Keys<T>>;
+type Changes<C extends Columns> = {
+    set?: InferForUpdate<C>;
+    inc?: {
+        [K in NumericKeys<C>]?: number;
+    };
+};
+type Conflict<C extends Columns> = {
+    on: (keyof C & string)[];
+    do: 'nothing' | 'throw' | (Changes<C> & {
+        replace?: (keyof InferForUpdate<C> & string)[];
+    });
+};
+type InsertOptions<C extends Columns> = {
+    conflict?: Conflict<C>;
+};
+declare class InsertBuilder<T extends Table> {
+    private readonly table;
+    private readonly rows;
+    constructor(table: T, rows?: InferForInsert<ColumnsOf<T>>[]);
+    values(rows: InferForInsert<ColumnsOf<T>> | InferForInsert<ColumnsOf<T>>[]): InsertBuilder<T>;
+    insert(db: IDatabase, options?: InsertOptions<ColumnsOf<T>> & {
+        returning?: true;
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
+    insert(db: IDatabase, options: InsertOptions<ColumnsOf<T>> & {
+        returning: false;
+    }): Promise<undefined>;
+    insert<R extends Returnable<T>>(db: IDatabase, options: InsertOptions<ColumnsOf<T>> & {
+        returning: R[];
+    }): Promise<Returned<T, R>[]>;
+    private renderConflict;
+}
+declare const into: <T extends Table>(table: T) => InsertBuilder<T>;
+type Direction = 'ASC' | 'DESC';
+type Field = [key: string, node: Node];
+type Query = {
+    table: Table;
+    scope: Scope;
+    joins: {
+        table: Table;
+        on: Node;
+    }[];
+    select?: Field[];
+    where: Node[];
+    groupBy: Node[];
+    orderBy: [Node, Direction][];
+    limit?: number;
+    offset?: number;
+};
+declare class QueryBuilder<T extends Table, A extends string = AliasOf<T>, N extends string = never, R = InferForSelect<ColumnsOf<T>>> {
+    private readonly query;
+    constructor(query: Query);
+    select<P extends Record<string, Operand<A>>>(projection: P): QueryBuilder<T, A, N, Expand<{ [K in keyof P & string]: ValueIn<P[K], N>; }>>;
+    where<L extends Operand<A>, O extends Op>(lhs: L, op: O, rhs: RhsFor<ValueIn<L, N>, O, A>): QueryBuilder<T, A, N, R>;
+    where(condition: Condition<A>): QueryBuilder<T, A, N, R>;
+    leftJoin<J extends Table>(table: J, on: Condition<A | AliasOf<J>>): QueryBuilder<T, A | AliasOf<J>, N | AliasOf<J>, R>;
+    groupBy(operands: Operand<A>[]): QueryBuilder<T, A, N, R>;
+    orderBy(operands: (Operand<A> | [Operand<A>, Direction])[]): QueryBuilder<T, A, N, R>;
+    limit(n: number): QueryBuilder<T, A, N, R>;
+    offset(n: number): QueryBuilder<T, A, N, R>;
+    all(db: IDatabase): Promise<R[]>;
+    one(db: IDatabase): Promise<NonNullable<R> | null>;
+    exists(db: IDatabase): Promise<boolean>;
+    count(db: IDatabase): Promise<number>;
+    update(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
+        returning: false;
+    }): Promise<undefined>;
+    update<K extends Returnable<T>>(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
+        returning: K[];
+    }): Promise<Returned<T, K>[]>;
+    update(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
+        returning?: true;
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
+    delete(db: IDatabase, options: {
+        returning: true;
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
+    delete<K extends Returnable<T>>(db: IDatabase, options: {
+        returning: K[];
+    }): Promise<Returned<T, K>[]>;
+    delete(db: IDatabase, options?: {
+        returning?: false;
+    }): Promise<undefined>;
+    private fields;
+    private renderSelect;
+    private top;
+    private assertPlain;
+}
+declare const from: <T extends Table>(table: T) => QueryBuilder<T, AliasOf<T>, never, Expand<ColumnsOf<T> extends infer T_1 extends Columns ? { [K in keyof T_1]: T_1[K]["output"]; } : never>>;
+type IndexOptions = {
+    ifNotExists?: boolean;
+    name?: string;
+};
+declare const createIndex: <T extends Table>(table: T, keys: Keys<T>[], { ifNotExists, name, unique, }?: IndexOptions & {
+    unique?: boolean;
+}) => {
+    onto: (db: IDatabase) => Promise<void>;
+};
+declare const create: {
+    table: (table: Table, { ifNotExists }?: {
+        ifNotExists?: boolean;
+    }) => {
+        onto: (db: IDatabase) => Promise<void>;
+    };
+    index: typeof createIndex;
+    uniqueIndex: <T extends Table>(table: T, keys: Keys<T>[], options?: IndexOptions) => {
+        onto: (db: IDatabase) => Promise<void>;
+    };
+};
+type Migration = (db: IDatabase) => Promise<void>;
+declare const defineMigrations: (migrations: Record<string, Migration>) => (db: IDatabase) => Promise<void>;
+export { type Codec, type Column, type ColumnProps, type ColumnRef, type Dialect, type DialectName, type IDatabase, type ILogger, type Infer, type Migration, type Operand, type Primitive, type Row, type Table, ValidationError, column, create, defineMigrations, defineTable as table, defineType, embedded, exec, expr, f, from, into, parse, types as t, };

package/dist/types/standard-schema.d.ts

@@ -0,0 +1,180 @@
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    export interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    export interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    export interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    export interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    export interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    export interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+    export {};
+}
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export { type StandardSchemaV1 as Schema };
+/**
+ * @public  Infers the input type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type input<T extends StandardSchemaV1> = StandardSchemaV1.InferInput<T>;
+/**
+ * @public  Infers the output type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type output<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+/**
+ * @public  Thrown when a value fails validation, carrying every issue found.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare class ValidationError extends Error {
+    readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+    constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const parse: <T extends StandardSchemaV1>(schema: T, value: unknown) => StandardSchemaV1.Result<output<T>>;
+/**
+ * @public  Like {@link parse}, but returns the value or throws a
+ *          {@link ValidationError}.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const parseOrThrow: <T extends StandardSchemaV1>(schema: T, value: unknown) => output<T>;
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const array: <T extends StandardSchemaV1>(schema: T) => StandardSchemaV1<input<T>[], output<T>[]>;
+/**
+ * @public  Defines a standard schema for bigints.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const bigint: () => StandardSchemaV1<bigint, bigint>;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const boolean: () => StandardSchemaV1<boolean, 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 declare const date: () => StandardSchemaV1<string | number | Date, Date>;
+/**
+ * @public  Defines a standard schema for one of the given string values.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const enumOf: <const T extends readonly string[]>(values: T) => StandardSchemaV1<T[number], T[number]>;
+/**
+ * @public  Defines a standard schema for instances of a given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const instanceOf: <T>(ctor: new (...args: any[]) => T) => StandardSchemaV1<T, T>;
+/**
+ * @public  Defines a standard schema for integers, within the safe integer
+ *          range by default.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const integer: ({ min, max }?: {
+    max?: number | undefined;
+    min?: number | undefined;
+}) => StandardSchemaV1<number, number>;
+/**
+ * @public  Defines a standard schema for calendar dates as `YYYY-MM-DD`
+ *          strings.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const isoDate: () => StandardSchemaV1<string, string>;
+/**
+ * @public  Makes a given standard schema accept `null`.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const nullable: <T extends StandardSchemaV1>(schema: T) => StandardSchemaV1<input<T> | null, output<T> | null>;
+/**
+ * @public  Defines a standard schema for finite numbers.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const number: () => StandardSchemaV1<number, number>;
+/**
+ * @public  Makes a given standard schema accept `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const optional: <T extends StandardSchemaV1>(schema: T) => StandardSchemaV1<input<T> | undefined, output<T> | undefined>;
+/**
+ * @public  Defines a standard schema for plain objects with string keys.
+ * @since   0.2.0
+ * @version 1
+ */
+export declare const record: () => StandardSchemaV1<Record<string, unknown>, Record<string, unknown>>;
+/**
+ * @public  Defines a standard schema for strings, optionally limited in
+ *          length.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const string: ({ max }?: {
+    max?: number;
+}) => StandardSchemaV1<string, string>;
+/**
+ * @public  Defines a standard schema for objects of a given shape. Keys
+ *          missing from the shape are rejected, keys missing from the input
+ *          are validated as `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+type Expand<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : never;
+type OptionalKeys<T extends Record<string, StandardSchemaV1>> = {
+    [K in keyof T]: undefined extends input<T[K]> ? K : never;
+}[keyof T];
+export declare const strictObject: <T extends Record<string, StandardSchemaV1>>(shape: T) => StandardSchemaV1<Expand<{ [K in Exclude<keyof T, OptionalKeys<T>>]: input<T[K]>; } & { [K in OptionalKeys<T>]?: input<T[K]> | undefined; }>, Expand<{ [K in Exclude<keyof T, OptionalKeys<T>>]: output<T[K]>; } & { [K in OptionalKeys<T>]?: output<T[K]> | undefined; }>>;
+/**
+ * @public  Defines a standard schema for UUID strings (any version).
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const uuid: () => StandardSchemaV1<string, string>;

package/dist/types/utils.d.ts

@@ -0,0 +1,11 @@
+type Ctor<T> = new (...args: any[]) => T;
+export type Expand<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : never;
+export type CamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelCase<U>>}` : S;
+export declare const camelCase: <T extends string>(str: T) => CamelCase<T>;
+export declare const snakeCase: (str: string) => string;
+export declare const wrap: <T>(value: T | T[]) => T[];
+export declare function raise(message: string, cause?: Error): never;
+export declare function raise(ctor: Ctor<Error>, message: string, cause?: Error): never;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/exto",
-  "description": "A zero-dependencies teeny tiny ORM for SQL databases.",
-  "version": "0.1.1",
+  "description": "A teeny tiny, type-safe query builder for Bun, with adapters for SQLite and PostgreSQL.",
+  "version": "0.2.0",
   "author": "Rafael Willians <me@rwillians.com>",
   "license": "MIT",
   "publishConfig": {
@@ -12,12 +12,9 @@
     "url": "git://github.com/rwillians/exto.git"
   },
   "keywords": [
-    "builder",
     "bun",
-    "orm",
+    "migrations",
     "postgres",
-    "query builder",
-    "query",
     "sql",
     "sqlite",
     "type-safe",
@@ -27,7 +24,10 @@
   "type": "module",
   "module": "dist/esm/index.js",
   "main": "dist/cjs/index.js",
-  "files": ["dist/", "LICENSE"],
+  "files": [
+    "dist/",
+    "LICENSE"
+  ],
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -57,9 +57,10 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "typescript": "^7.1.0-dev.20261114.1",
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "typescript": "^7"
+    "typescript": "^7.1.0-0"
   }
 }

package/dist/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore