@rwillians/exto 0.1.2 → 0.2.0

package/dist/esm/standard-schema.js

@@ -184,6 +184,14 @@ export const number = () => define((input) => Number.isFinite(input)
 export const optional = (schema) => define((input) => input === undefined
     ? { value: undefined }
     : parse(schema, input));
+/**
+ * @public  Defines a standard schema for plain objects with string keys.
+ * @since   0.2.0
+ * @version 1
+ */
+export const record = () => define((input) => typeof input === 'object' && input !== null && Object.getPrototypeOf(input) === Object.prototype
+    ? { value: input }
+    : fail('must be a plain object'));
 /**
  * @public  Defines a standard schema for strings, optionally limited in
  *          length.

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

@@ -8,6 +8,7 @@ declare class BunPostgres implements IDatabase {
     readonly dialect: Dialect;
     constructor(sql: SQL, loggers?: ILogger[], inTransaction?: boolean);
     execute(sql: string, params: unknown[]): Promise<Row[] & SQL.ResultMetadata>;
+    close(): Promise<void>;
     transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
 }
 declare const connect: (url: string, { loggers }?: {

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

@@ -8,6 +8,7 @@ declare class BunSQLite implements IDatabase {
     readonly dialect: Dialect;
     constructor(conn: Database, loggers?: ILogger[], depth?: number);
     execute(sql: string, params: unknown[]): Promise<Row[]>;
+    close(): Promise<void>;
     transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
 }
 declare const connect: (filename?: string, { loggers }?: {

package/dist/types/index.d.ts

@@ -1,7 +1,8 @@
 import * as std from './standard-schema';
 import { ValidationError } from './standard-schema';
-import { type CamelCase, type Expand } from './utils';
-type Primitive = 'BIGINT' | 'BINARY' | 'BOOLEAN' | 'CITEXT' | 'DATE' | 'DATETIME' | 'DECIMAL' | 'FLOAT' | 'INTEGER' | 'JSON' | 'SEQUENCE' | 'STRING' | 'TEXT' | 'UUID';
+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;
@@ -13,6 +14,8 @@ type ColumnProps<S extends std.Schema = std.Schema> = {
     nullable?: true;
     primaryKey?: true;
     unique?: true;
+    fields?: Columns;
+    many?: true;
 };
 type Column<K extends string = string, P extends ColumnProps = ColumnProps> = P & {
     key: K;
@@ -20,6 +23,7 @@ type Column<K extends string = string, P extends ColumnProps = ColumnProps> = P
     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);
@@ -29,7 +33,7 @@ declare class ColumnBuilder<P extends ColumnProps> {
     generated(): ColumnBuilder<Expand<P & {
         generated: true;
     }>>;
-    nullable(): ColumnBuilder<Expand<Omit<P, "schema"> & {
+    optional(): ColumnBuilder<Expand<Omit<P, "schema"> & {
         nullable: true;
         schema: std.Schema<std.input<P['schema']> | null, std.output<P['schema']> | null>;
     }>>;
@@ -39,8 +43,35 @@ declare class ColumnBuilder<P extends ColumnProps> {
     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";
@@ -62,10 +93,6 @@ declare const types: {
         type: "DATE";
         schema: std.Schema<string, string>;
     }>;
-    datetime: () => ColumnBuilder<{
-        type: "DATETIME";
-        schema: std.Schema<string | number | Date, Date>;
-    }>;
     decimal: (options?: {
         precision: number;
         scale: number;
@@ -92,6 +119,10 @@ declare const types: {
         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>;
@@ -108,17 +139,75 @@ declare const types: {
         type: "TEXT";
         schema: std.Schema<string, string>;
     }>;
-    uuid: () => ColumnBuilder<{
+    timestamp: () => ColumnBuilder<{
+        type: "TIMESTAMP";
+        schema: std.Schema<string | number | Date, Date>;
+    }>;
+    uuidv7: () => ColumnBuilder<{
         type: "UUID";
         schema: std.Schema<string, string>;
     }>;
 };
-type Columns = Record<string, Column>;
-type Table<N extends string = string, C extends Columns = Columns> = {
-    name: N;
+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;
-    columns: C;
+    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;
 };
@@ -132,8 +221,7 @@ type OmitOnUpdate = {
 } | {
     primaryKey: true;
 };
-type NumericType = 'BIGINT' | 'DECIMAL' | 'FLOAT' | 'INTEGER';
-type Infer<C extends Columns> = Expand<{
+type InferForSelect<C extends Columns> = Expand<{
     [K in keyof C]: C[K]['output'];
 }>;
 type InferForInsert<C extends Columns> = Expand<{
@@ -144,20 +232,31 @@ type InferForInsert<C extends Columns> = Expand<{
 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];
-type DefinedTable<N extends string, C extends Columns> = Table<N, C> & {
-    as: (alias: string) => DefinedTable<N, C>;
-    infer: Infer<C>;
-    inferForInsert: InferForInsert<C>;
-    inferForUpdate: InferForUpdate<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 Record<string, ColumnBuilder<ColumnProps>>>(name: N, shapeFn: (t: typeof types) => S) => DefinedTable<N, { [K in keyof S & string as CamelCase<K>]: Column<CamelCase<K>, S[K]['props']>; }>;
+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.
@@ -165,13 +264,17 @@ type Codec = {
  * `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).
  */
-type DialectName = 'postgres' | 'sqlite' | (string & {});
 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 {
@@ -186,32 +289,43 @@ interface IDatabase {
     transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
 }
 declare const exec: (db: IDatabase, sql: string, params?: unknown[]) => Promise<void>;
-type Op = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'like' | 'not like' | 'in' | 'not in' | 'is' | 'is not';
-type ValueFor<V, O extends Op> = O extends 'is' | 'is not' ? null : O extends 'in' | 'not in' ? NonNullable<V>[] : O extends 'like' | 'not like' ? string : NonNullable<V>;
-type ExprNode = {
-    key: string;
-    op: Op;
-    value: unknown;
-} | {
-    group: 'AND' | 'OR';
-    exprs: ExprNode[];
-};
-declare const COLUMNS: unique symbol;
-type Expr<C extends Columns> = ExprNode & {
-    readonly [COLUMNS]?: (columns: C) => C;
-};
-declare const expr: (<C extends Columns, K extends keyof C & string, O extends Op>(key: K, op: O, value: ValueFor<C[K]['output'], O>) => Expr<C>) & {
-    and: <C extends Columns>(exprs: Expr<C>[]) => Expr<C>;
-    or: <C extends Columns>(exprs: Expr<C>[]) => Expr<C>;
+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>>;
 };
-type Condition = {
-    col: Column;
-    op: Op;
-    value: unknown;
-} | {
-    group: 'AND' | 'OR';
-    conditions: Condition[];
+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?: {
@@ -230,71 +344,80 @@ type InsertOptions<C extends Columns> = {
 declare class InsertBuilder<T extends Table> {
     private readonly table;
     private readonly rows;
-    constructor(table: T, rows?: InferForInsert<T['columns']>[]);
-    values(rows: InferForInsert<T['columns']> | InferForInsert<T['columns']>[]): InsertBuilder<T>;
-    insert(db: IDatabase, options?: InsertOptions<T['columns']> & {
+    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<Infer<T['columns']>[]>;
-    insert(db: IDatabase, options: InsertOptions<T['columns']> & {
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
+    insert(db: IDatabase, options: InsertOptions<ColumnsOf<T>> & {
         returning: false;
     }): Promise<undefined>;
-    insert<K extends keyof T['columns'] & string>(db: IDatabase, options: InsertOptions<T['columns']> & {
-        returning: K[];
-    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
+    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 Query<T extends Table> = {
-    table: T;
-    select?: string[];
-    where: Condition[];
-    orderBy: [Column, Direction][];
+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;
 };
-type Keys<T extends Table> = keyof T['columns'] & string;
-declare class QueryBuilder<T extends Table, S extends Keys<T> = Keys<T>> {
+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<T>);
-    select<K extends Keys<T>>(keys: K[]): QueryBuilder<T, K>;
-    where<K extends Keys<T>, O extends Op>(key: K, op: O, value: ValueFor<T['columns'][K]['output'], O>): QueryBuilder<T, S>;
-    where(expr: Expr<T['columns']>): QueryBuilder<T, S>;
-    orderBy(keys: (Keys<T> | [Keys<T>, Direction])[]): QueryBuilder<T, S>;
-    limit(n: number): QueryBuilder<T, S>;
-    offset(n: number): QueryBuilder<T, S>;
-    all(db: IDatabase): Promise<Expand<Pick<Expand<T["columns"] extends infer T_1 extends Columns ? { [K in keyof T_1]: T_1[K]["output"]; } : never>, S>>[]>;
-    one(db: IDatabase): Promise<Expand<Pick<Expand<T["columns"] extends infer T_1 extends Columns ? { [K in keyof T_1]: T_1[K]["output"]; } : never>, S>>>;
+    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<T['columns']> & {
+    update(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
         returning: false;
     }): Promise<undefined>;
-    update<K extends keyof T['columns'] & string>(db: IDatabase, changes: Changes<T['columns']> & {
+    update<K extends Returnable<T>>(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
         returning: K[];
-    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
-    update(db: IDatabase, changes: Changes<T['columns']> & {
+    }): Promise<Returned<T, K>[]>;
+    update(db: IDatabase, changes: Changes<ColumnsOf<T>> & {
         returning?: true;
-    }): Promise<Infer<T['columns']>[]>;
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
     delete(db: IDatabase, options: {
         returning: true;
-    }): Promise<Infer<T['columns']>[]>;
-    delete<K extends keyof T['columns'] & string>(db: IDatabase, options: {
+    }): Promise<InferForSelect<ColumnsOf<T>>[]>;
+    delete<K extends Returnable<T>>(db: IDatabase, options: {
         returning: K[];
-    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
+    }): Promise<Returned<T, K>[]>;
     delete(db: IDatabase, options?: {
         returning?: false;
     }): Promise<undefined>;
+    private fields;
     private renderSelect;
     private top;
-    private assertUnbounded;
+    private assertPlain;
 }
-declare const from: <T extends Table>(table: T) => QueryBuilder<T, Keys<T>>;
+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: (keyof T['columns'] & string)[], { ifNotExists, name, unique, }?: IndexOptions & {
+declare const createIndex: <T extends Table>(table: T, keys: Keys<T>[], { ifNotExists, name, unique, }?: IndexOptions & {
     unique?: boolean;
 }) => {
     onto: (db: IDatabase) => Promise<void>;
@@ -306,10 +429,10 @@ declare const create: {
         onto: (db: IDatabase) => Promise<void>;
     };
     index: typeof createIndex;
-    uniqueIndex: <T extends Table>(table: T, keys: (keyof T['columns'] & string)[], options?: IndexOptions) => {
+    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 Dialect, type DialectName, type Expr, type IDatabase, type ILogger, type Migration, type Primitive, type Row, type Table, ValidationError, column, create, defineMigrations, defineTable as table, exec, expr, from, into, types as t, };
+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

@@ -143,6 +143,12 @@ export declare const number: () => StandardSchemaV1<number, number>;
  * @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.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/exto",
-  "description": "A zero-dependencies teeny tiny ORM for SQL databases.",
-  "version": "0.1.2",
+  "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"
   }
 }