rado 0.1.53 → 0.1.55

package/dist/define/Column.d.ts

@@ -1,58 +1,58 @@
-import { EV, Expr, ExprData } from './Expr';
-export declare enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-interface PartialColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: ExprData | (() => ExprData);
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-    references?: () => ExprData;
-}
-export interface ColumnData extends PartialColumnData {
-    type: ColumnType;
-    name: string;
-}
-export declare class Column<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.IsOptional<T>>;
-    primaryKey<K extends string>(create?: () => EV<T>): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
-    unique(): Column<T>;
-    defaultValue(create: () => EV<T>): Column<Column.IsOptional<T>>;
-    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
-}
-export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
-};
-export declare namespace Column {
-    const isOptional: unique symbol;
-    type IsOptional<T> = {
-        [isOptional]: true;
-        __t: T;
-    };
-    const isPrimary: unique symbol;
-    type IsPrimary<T, K> = {
-        [isPrimary]: K;
-        __t: T;
-    };
-}
-export declare const column: {
-    string<T extends string = string>(): Column<T>;
-    integer<T_1 extends number = number>(): Column<T_1>;
-    number<T_2 extends number = number>(): Column<T_2>;
-    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
-    object<T_4 extends object = object>(): Column<T_4>;
-    array<T_5 = any>(): Column<T_5[]>;
-};
-export {};
+import { EV, Expr, ExprData } from './Expr';
+export declare enum ColumnType {
+    String = "String",
+    Integer = "Integer",
+    Number = "Number",
+    Boolean = "Boolean",
+    Json = "Json"
+}
+interface PartialColumnData {
+    type: ColumnType;
+    name?: string;
+    nullable?: boolean;
+    defaultValue?: ExprData | (() => ExprData);
+    autoIncrement?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    references?: () => ExprData;
+}
+export interface ColumnData extends PartialColumnData {
+    type: ColumnType;
+    name: string;
+}
+export declare class Column<T> {
+    data: PartialColumnData;
+    constructor(data: PartialColumnData);
+    name(name: string): Column<T>;
+    nullable(): Column<T | null>;
+    autoIncrement(): Column<Column.IsOptional<T>>;
+    primaryKey<K extends string>(create?: () => EV<T>): Column<Column.IsPrimary<T, K>>;
+    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
+    unique(): Column<T>;
+    defaultValue(create: () => EV<T>): Column<Column.IsOptional<T>>;
+    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
+}
+export type PrimaryKey<T, K> = string extends K ? T : T & {
+    [Column.isPrimary]: K;
+};
+export declare namespace Column {
+    const isOptional: unique symbol;
+    type IsOptional<T> = {
+        [isOptional]: true;
+        __t: T;
+    };
+    const isPrimary: unique symbol;
+    type IsPrimary<T, K> = {
+        [isPrimary]: K;
+        __t: T;
+    };
+}
+export declare const column: {
+    string<T extends string = string>(): Column<T>;
+    integer<T_1 extends number = number>(): Column<T_1>;
+    number<T_2 extends number = number>(): Column<T_2>;
+    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
+    object<T_4 extends object = object>(): Column<T_4>;
+    array<T_5 = any>(): Column<T_5[]>;
+};
+export {};

package/dist/define/Cursor.d.ts

@@ -1,85 +1,86 @@
-import { Driver } from '../lib/Driver';
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
-export declare class Cursor<T> {
-    [Selection.__cursorType](): T;
-    constructor(query: Query<T>);
-    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    query(): Query<T>;
-    on(driver: Driver.Sync): T;
-    on(driver: Driver.Async): Promise<T>;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Delete extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-        where(...where: Array<EV<boolean>>): Delete;
-        take(limit: number | undefined): Delete;
-        skip(offset: number | undefined): Delete;
-    }
-    class Update<T> extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-        where(...where: Array<EV<boolean>>): Update<T>;
-        take(limit: number | undefined): Update<T>;
-        skip(offset: number | undefined): Update<T>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class InsertValues extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Insert;
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
-    }
-    class CreateTable extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        constructor(queries: Array<Query>);
-    }
-    class SelectMultiple<T> extends Cursor<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        sure(): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        take(limit: number | undefined): SelectMultiple<T>;
-        skip(offset: number | undefined): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Cursor<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        take(limit: number | undefined): SelectSingle<T>;
-        skip(offset: number | undefined): SelectSingle<T>;
-        all(): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-}
+import { Driver } from '../lib/Driver';
+import { EV, Expr } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Query } from './Query';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Table } from './Table';
+import { Update as UpdateSet } from './Update';
+export declare class Cursor<T> {
+    [Selection.__cursorType](): T;
+    constructor(query: Query<T>);
+    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
+    query(): Query<T>;
+    on(driver: Driver.Sync): T;
+    on(driver: Driver.Async): Promise<T>;
+    compile(driver: Driver): import("..").Statement;
+    toJSON(): Query<T>;
+}
+export declare namespace Cursor {
+    class Delete extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+        where(...where: Array<EV<boolean>>): Delete;
+        take(limit: number | undefined): Delete;
+        skip(offset: number | undefined): Delete;
+    }
+    class Update<T> extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Update;
+        set(set: UpdateSet<T>): Update<T>;
+        where(...where: Array<EV<boolean>>): Update<T>;
+        take(limit: number | undefined): Update<T>;
+        skip(offset: number | undefined): Update<T>;
+    }
+    class InsertValuesReturning<T> extends Cursor<T> {
+    }
+    class InsertValues extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Insert;
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    class Insert<T> {
+        protected into: Schema;
+        constructor(into: Schema);
+        values(...data: Array<Table.Insert<T>>): InsertValues;
+    }
+    class CreateTable extends Cursor<void> {
+        protected table: Schema;
+        constructor(table: Schema);
+    }
+    class Batch<T = void> extends Cursor<T> {
+        protected queries: Array<Query>;
+        constructor(queries: Array<Query>);
+    }
+    class SelectMultiple<T> extends Cursor<Array<T>> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+        count(): SelectSingle<number>;
+        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
+        first(): SelectSingle<T | undefined>;
+        sure(): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
+        take(limit: number | undefined): SelectMultiple<T>;
+        skip(offset: number | undefined): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+    class SelectSingle<T> extends Cursor<T> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
+        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        take(limit: number | undefined): SelectSingle<T>;
+        skip(offset: number | undefined): SelectSingle<T>;
+        all(): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+}

package/dist/define/Cursor.js

@@ -24,6 +24,9 @@ var Cursor = class {
   on(driver) {
     return driver.executeQuery(this.query());
   }
+  compile(driver) {
+    return driver.formatter.compile(this.query());
+  }
   toJSON() {
     return this.query();
   }

package/dist/define/Expr.d.ts

@@ -1,154 +1,154 @@
-import { Cursor } from './Cursor';
-import { Fields } from './Fields';
-import { OrderBy } from './OrderBy';
-import { ParamData } from './Param';
-import { Query } from './Query';
-import { Selection } from './Selection';
-import { Target } from './Target';
-export declare enum UnOp {
-    Not = "Not",
-    IsNull = "IsNull"
-}
-export declare enum BinOp {
-    Add = "Add",
-    Subt = "Subt",
-    Mult = "Mult",
-    Mod = "Mod",
-    Div = "Div",
-    Greater = "Greater",
-    GreaterOrEqual = "GreaterOrEqual",
-    Less = "Less",
-    LessOrEqual = "LessOrEqual",
-    Equals = "Equals",
-    NotEquals = "NotEquals",
-    And = "And",
-    Or = "Or",
-    Like = "Like",
-    Glob = "Glob",
-    Match = "Match",
-    In = "In",
-    NotIn = "NotIn",
-    Concat = "Concat"
-}
-export declare enum ExprType {
-    UnOp = "UnOp",
-    BinOp = "BinOp",
-    Field = "Field",
-    Param = "Param",
-    Call = "Call",
-    Query = "Query",
-    Record = "Record",
-    Row = "Row",
-    Map = "Map",
-    Filter = "Filter",
-    Merge = "Merge",
-    Case = "Case"
-}
-export type ExprData = {
-    type: ExprType.UnOp;
-    op: UnOp;
-    expr: ExprData;
-} | {
-    type: ExprType.BinOp;
-    op: BinOp;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Field;
-    expr: ExprData;
-    field: string;
-} | {
-    type: ExprType.Param;
-    param: ParamData;
-} | {
-    type: ExprType.Call;
-    method: string;
-    params: Array<ExprData>;
-} | {
-    type: ExprType.Query;
-    query: Query.Select;
-} | {
-    type: ExprType.Record;
-    fields: Record<string, ExprData>;
-} | {
-    type: ExprType.Merge;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Row;
-    target: Target;
-} | {
-    type: ExprType.Map;
-    target: Target;
-    result: ExprData;
-} | {
-    type: ExprType.Filter;
-    target: Target;
-    condition: ExprData;
-} | {
-    type: ExprType.Case;
-    expr: ExprData;
-    cases: Record<string, ExprData>;
-    defaultCase?: ExprData;
-};
-export declare const ExprData: {
-    UnOp(op: UnOp, expr: ExprData): ExprData;
-    BinOp(op: BinOp, a: ExprData, b: ExprData): ExprData;
-    Field(expr: ExprData, field: string): ExprData;
-    Param(param: ParamData): ExprData;
-    Call(method: string, params: Array<ExprData>): ExprData;
-    Query(query: Query.Select): ExprData;
-    Record(fields: Record<string, ExprData>): ExprData;
-    Merge(a: ExprData, b: ExprData): ExprData;
-    Row(target: Target): ExprData;
-    Map(target: Target, result: ExprData): ExprData;
-    Filter(target: Target, condition: ExprData): ExprData;
-    Case(expr: ExprData, cases: Record<string, ExprData>, defaultCase?: ExprData): ExprData;
-    create(input: any): ExprData;
-};
-/** Expression or value of type T */
-export type EV<T> = Expr<T> | T;
-export declare class Expr<T> {
-    expr: ExprData;
-    static NULL: ExprData;
-    static value<T>(value: T): Expr<T>;
-    static create<T>(input: EV<T>): Expr<T>;
-    static and(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    static or(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    constructor(expr: ExprData);
-    asc(): OrderBy;
-    desc(): OrderBy;
-    not(): Expr<boolean>;
-    or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    isNull(): Expr<boolean>;
-    isNotNull(): Expr<boolean>;
-    isNot(that: EV<T>): Expr<boolean>;
-    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
-    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
-    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
-    add(this: Expr<number>, that: EV<number>): Expr<number>;
-    substract(this: Expr<number>, that: EV<number>): Expr<number>;
-    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
-    remainder(this: Expr<number>, that: EV<number>): Expr<number>;
-    divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    greater(that: EV<any>): Expr<boolean>;
-    greaterOrEqual(that: EV<any>): Expr<boolean>;
-    less(that: EV<any>): Expr<boolean>;
-    lessOrEqual(that: EV<any>): Expr<boolean>;
-    concat(this: Expr<string>, that: EV<string>): Expr<string>;
-    like(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    match(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    with<X extends Selection>(that: X): Selection.With<T, X>;
-    at<T>(this: Expr<Array<T>>, index: number): Expr<T | null>;
-    filter<T>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => Expr<boolean>): Expr<Array<T>>;
-    map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
-    sure(): Expr<NonNullable<T>>;
-    get<T>(name: string): Expr<T>;
-}
-export declare namespace Expr {
-    type Record<T> = Expr<T> & {
-        [K in keyof T]: Expr<T[K]>;
-    };
-}
+import { Cursor } from './Cursor';
+import { Fields } from './Fields';
+import { OrderBy } from './OrderBy';
+import { ParamData } from './Param';
+import { Query } from './Query';
+import { Selection } from './Selection';
+import { Target } from './Target';
+export declare enum UnOp {
+    Not = "Not",
+    IsNull = "IsNull"
+}
+export declare enum BinOp {
+    Add = "Add",
+    Subt = "Subt",
+    Mult = "Mult",
+    Mod = "Mod",
+    Div = "Div",
+    Greater = "Greater",
+    GreaterOrEqual = "GreaterOrEqual",
+    Less = "Less",
+    LessOrEqual = "LessOrEqual",
+    Equals = "Equals",
+    NotEquals = "NotEquals",
+    And = "And",
+    Or = "Or",
+    Like = "Like",
+    Glob = "Glob",
+    Match = "Match",
+    In = "In",
+    NotIn = "NotIn",
+    Concat = "Concat"
+}
+export declare enum ExprType {
+    UnOp = "UnOp",
+    BinOp = "BinOp",
+    Field = "Field",
+    Param = "Param",
+    Call = "Call",
+    Query = "Query",
+    Record = "Record",
+    Row = "Row",
+    Map = "Map",
+    Filter = "Filter",
+    Merge = "Merge",
+    Case = "Case"
+}
+export type ExprData = {
+    type: ExprType.UnOp;
+    op: UnOp;
+    expr: ExprData;
+} | {
+    type: ExprType.BinOp;
+    op: BinOp;
+    a: ExprData;
+    b: ExprData;
+} | {
+    type: ExprType.Field;
+    expr: ExprData;
+    field: string;
+} | {
+    type: ExprType.Param;
+    param: ParamData;
+} | {
+    type: ExprType.Call;
+    method: string;
+    params: Array<ExprData>;
+} | {
+    type: ExprType.Query;
+    query: Query.Select;
+} | {
+    type: ExprType.Record;
+    fields: Record<string, ExprData>;
+} | {
+    type: ExprType.Merge;
+    a: ExprData;
+    b: ExprData;
+} | {
+    type: ExprType.Row;
+    target: Target;
+} | {
+    type: ExprType.Map;
+    target: Target;
+    result: ExprData;
+} | {
+    type: ExprType.Filter;
+    target: Target;
+    condition: ExprData;
+} | {
+    type: ExprType.Case;
+    expr: ExprData;
+    cases: Record<string, ExprData>;
+    defaultCase?: ExprData;
+};
+export declare const ExprData: {
+    UnOp(op: UnOp, expr: ExprData): ExprData;
+    BinOp(op: BinOp, a: ExprData, b: ExprData): ExprData;
+    Field(expr: ExprData, field: string): ExprData;
+    Param(param: ParamData): ExprData;
+    Call(method: string, params: Array<ExprData>): ExprData;
+    Query(query: Query.Select): ExprData;
+    Record(fields: Record<string, ExprData>): ExprData;
+    Merge(a: ExprData, b: ExprData): ExprData;
+    Row(target: Target): ExprData;
+    Map(target: Target, result: ExprData): ExprData;
+    Filter(target: Target, condition: ExprData): ExprData;
+    Case(expr: ExprData, cases: Record<string, ExprData>, defaultCase?: ExprData): ExprData;
+    create(input: any): ExprData;
+};
+/** Expression or value of type T */
+export type EV<T> = Expr<T> | T;
+export declare class Expr<T> {
+    expr: ExprData;
+    static NULL: ExprData;
+    static value<T>(value: T): Expr<T>;
+    static create<T>(input: EV<T>): Expr<T>;
+    static and(...conditions: Array<EV<boolean>>): Expr<boolean>;
+    static or(...conditions: Array<EV<boolean>>): Expr<boolean>;
+    constructor(expr: ExprData);
+    asc(): OrderBy;
+    desc(): OrderBy;
+    not(): Expr<boolean>;
+    or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
+    and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
+    isNull(): Expr<boolean>;
+    isNotNull(): Expr<boolean>;
+    isNot(that: EV<T>): Expr<boolean>;
+    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
+    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    add(this: Expr<number>, that: EV<number>): Expr<number>;
+    substract(this: Expr<number>, that: EV<number>): Expr<number>;
+    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
+    remainder(this: Expr<number>, that: EV<number>): Expr<number>;
+    divide(this: Expr<number>, that: EV<number>): Expr<number>;
+    greater(that: EV<any>): Expr<boolean>;
+    greaterOrEqual(that: EV<any>): Expr<boolean>;
+    less(that: EV<any>): Expr<boolean>;
+    lessOrEqual(that: EV<any>): Expr<boolean>;
+    concat(this: Expr<string>, that: EV<string>): Expr<string>;
+    like(this: Expr<string>, that: EV<string>): Expr<boolean>;
+    glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
+    match(this: Expr<string>, that: EV<string>): Expr<boolean>;
+    with<X extends Selection>(that: X): Selection.With<T, X>;
+    at<T>(this: Expr<Array<T>>, index: number): Expr<T | null>;
+    filter<T>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => Expr<boolean>): Expr<Array<T>>;
+    map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
+    sure(): Expr<NonNullable<T>>;
+    get<T>(name: string): Expr<T>;
+}
+export declare namespace Expr {
+    type Record<T> = Expr<T> & {
+        [K in keyof T]: Expr<T[K]>;
+    };
+}

package/dist/define/Fields.d.ts

@@ -1,13 +1,13 @@
-import { Column, PrimaryKey } from './Column';
-import { Expr } from './Expr';
-type ObjectUnion<T> = {
-    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
-};
-type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
-    [K in keyof Row]-?: Field<Row[K]>;
-} : never;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
-export {};
+import { Column, PrimaryKey } from './Column';
+import { Expr } from './Expr';
+type ObjectUnion<T> = {
+    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
+};
+type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
+type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
+type FieldsOf<Row> = Row extends Record<string, any> ? {
+    [K in keyof Row]-?: Field<Row[K]>;
+} : never;
+type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
+export {};

package/dist/define/Functions.d.ts

@@ -1,5 +1,5 @@
-import { Expr } from './Expr';
-export declare const Functions: Functions;
-export type Functions = {
-    [key: string]: (...args: Array<any>) => Expr<any>;
-};
+import { Expr } from './Expr';
+export declare const Functions: Functions;
+export type Functions = {
+    [key: string]: (...args: Array<any>) => Expr<any>;
+};