rado 0.1.62 → 0.1.64

package/dist/define/Expr.d.ts

@@ -1,172 +1,173 @@
-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 UnOpType {
-    Not = "Not",
-    IsNull = "IsNull"
-}
-export declare enum BinOpType {
-    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 = ExprData.UnOp | ExprData.BinOp | ExprData.Field | ExprData.Param | ExprData.Call | ExprData.Query | ExprData.Record | ExprData.Merge | ExprData.Row | ExprData.Map | ExprData.Filter | ExprData.Case;
-export declare namespace ExprData {
-    type UnOp = {
-        type: ExprType.UnOp;
-        op: UnOpType;
-        expr: ExprData;
-    };
-    type BinOp = {
-        type: ExprType.BinOp;
-        op: BinOpType;
-        a: ExprData;
-        b: ExprData;
-    };
-    type Field = {
-        type: ExprType.Field;
-        expr: ExprData;
-        field: string;
-    };
-    type Param = {
-        type: ExprType.Param;
-        param: ParamData;
-    };
-    type Call = {
-        type: ExprType.Call;
-        method: string;
-        params: Array<ExprData>;
-    };
-    type Query = {
-        type: ExprType.Query;
-        query: Query.Select;
-    };
-    type Record = {
-        type: ExprType.Record;
-        fields: {
-            [key: string]: ExprData;
-        };
-    };
-    type Merge = {
-        type: ExprType.Merge;
-        a: ExprData;
-        b: ExprData;
-    };
-    type Row = {
-        type: ExprType.Row;
-        target: Target;
-    };
-    type Map = {
-        type: ExprType.Map;
-        target: Target;
-        result: ExprData;
-    };
-    type Filter = {
-        type: ExprType.Filter;
-        target: Target;
-        condition: ExprData;
-    };
-    type Case = {
-        type: ExprType.Case;
-        expr: ExprData;
-        cases: {
-            [key: string]: ExprData;
-        };
-        defaultCase?: ExprData;
-    };
-}
-export declare const ExprData: {
-    UnOp(op: UnOpType, expr: ExprData): ExprData;
-    BinOp(op: BinOpType, 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 UnOpType {
+    Not = "Not",
+    IsNull = "IsNull"
+}
+export declare enum BinOpType {
+    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 = ExprData.UnOp | ExprData.BinOp | ExprData.Field | ExprData.Param | ExprData.Call | ExprData.Query | ExprData.Record | ExprData.Merge | ExprData.Row | ExprData.Map | ExprData.Filter | ExprData.Case;
+export declare namespace ExprData {
+    type UnOp = {
+        type: ExprType.UnOp;
+        op: UnOpType;
+        expr: ExprData;
+    };
+    type BinOp = {
+        type: ExprType.BinOp;
+        op: BinOpType;
+        a: ExprData;
+        b: ExprData;
+    };
+    type Field = {
+        type: ExprType.Field;
+        expr: ExprData;
+        field: string;
+    };
+    type Param = {
+        type: ExprType.Param;
+        param: ParamData;
+    };
+    type Call = {
+        type: ExprType.Call;
+        method: string;
+        params: Array<ExprData>;
+    };
+    type Query = {
+        type: ExprType.Query;
+        query: Query.Select;
+    };
+    type Record = {
+        type: ExprType.Record;
+        fields: {
+            [key: string]: ExprData;
+        };
+    };
+    type Merge = {
+        type: ExprType.Merge;
+        a: ExprData;
+        b: ExprData;
+    };
+    type Row = {
+        type: ExprType.Row;
+        target: Target;
+    };
+    type Map = {
+        type: ExprType.Map;
+        target: Target;
+        result: ExprData;
+    };
+    type Filter = {
+        type: ExprType.Filter;
+        target: Target;
+        condition: ExprData;
+    };
+    type Case = {
+        type: ExprType.Case;
+        expr: ExprData;
+        cases: {
+            [key: string]: ExprData;
+        };
+        defaultCase?: ExprData;
+    };
+}
+export declare const ExprData: {
+    UnOp(op: UnOpType, expr: ExprData): ExprData;
+    BinOp(op: BinOpType, 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>;
+    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
+    isNot(that: EV<T>): Expr<boolean>;
+    isNull(): Expr<boolean>;
+    isNotNull(): Expr<boolean>;
+    isIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isGreater(that: EV<any>): Expr<boolean>;
+    isGreaterOrEqual(that: EV<any>): Expr<boolean>;
+    isLess(that: EV<any>): Expr<boolean>;
+    isLessOrEqual(that: EV<any>): 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>;
+    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>;
+    includes<T>(this: Expr<Array<T>>, value: EV<T>): Expr<boolean>;
+    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/Expr.js

@@ -151,7 +151,7 @@ var _Expr = class {
     return { expr: this.expr, order: OrderDirection.Desc };
   }
   not() {
-    return unop(this, "Not" /* Not */);
+    return new _Expr(ExprData.UnOp("Not" /* Not */, this.expr));
   }
   or(that) {
     const a = this.expr;
@@ -171,66 +171,72 @@ var _Expr = class {
       return new _Expr(b);
     return new _Expr(ExprData.BinOp("And" /* And */, a, b));
   }
+  is(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNull();
+    return new _Expr(ExprData.BinOp("Equals" /* Equals */, this.expr, toExpr(that)));
+  }
+  isNot(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNotNull();
+    return new _Expr(
+      ExprData.BinOp("NotEquals" /* NotEquals */, this.expr, toExpr(that))
+    );
+  }
   isNull() {
-    return unop(this, "IsNull" /* IsNull */);
+    return new _Expr(ExprData.UnOp("IsNull" /* IsNull */, this.expr));
   }
   isNotNull() {
     return this.isNull().not();
   }
-  isNot(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNotNull();
-    return binop(this, "NotEquals" /* NotEquals */, that);
+  isIn(that) {
+    return new _Expr(ExprData.BinOp("In" /* In */, this.expr, toExpr(that)));
   }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
+  isNotIn(that) {
+    return new _Expr(ExprData.BinOp("NotIn" /* NotIn */, this.expr, toExpr(that)));
+  }
+  isGreater(that) {
+    return new _Expr(ExprData.BinOp("Greater" /* Greater */, this.expr, toExpr(that)));
   }
-  in(that) {
-    return binop(this, "In" /* In */, that);
+  isGreaterOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("GreaterOrEqual" /* GreaterOrEqual */, this.expr, toExpr(that))
+    );
   }
-  notIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
+  isLess(that) {
+    return new _Expr(ExprData.BinOp("Less" /* Less */, this.expr, toExpr(that)));
+  }
+  isLessOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this.expr, toExpr(that))
+    );
   }
   add(that) {
-    return binop(this, "Add" /* Add */, that);
+    return new _Expr(ExprData.BinOp("Add" /* Add */, this.expr, toExpr(that)));
   }
   substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
+    return new _Expr(ExprData.BinOp("Subt" /* Subt */, this.expr, toExpr(that)));
   }
   multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
+    return new _Expr(ExprData.BinOp("Mult" /* Mult */, this.expr, toExpr(that)));
   }
   remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
+    return new _Expr(ExprData.BinOp("Mod" /* Mod */, this.expr, toExpr(that)));
   }
   divide(that) {
-    return binop(this, "Div" /* Div */, that);
-  }
-  greater(that) {
-    return binop(this, "Greater" /* Greater */, that);
-  }
-  greaterOrEqual(that) {
-    return binop(this, "GreaterOrEqual" /* GreaterOrEqual */, that);
-  }
-  less(that) {
-    return binop(this, "Less" /* Less */, that);
-  }
-  lessOrEqual(that) {
-    return binop(this, "LessOrEqual" /* LessOrEqual */, that);
+    return new _Expr(ExprData.BinOp("Div" /* Div */, this.expr, toExpr(that)));
   }
   concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
+    return new _Expr(ExprData.BinOp("Concat" /* Concat */, this.expr, toExpr(that)));
   }
   like(that) {
-    return binop(this, "Like" /* Like */, that);
+    return new _Expr(ExprData.BinOp("Like" /* Like */, this.expr, toExpr(that)));
   }
   glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
+    return new _Expr(ExprData.BinOp("Glob" /* Glob */, this.expr, toExpr(that)));
   }
   match(that) {
-    return binop(this, "Match" /* Match */, that);
+    return new _Expr(ExprData.BinOp("Match" /* Match */, this.expr, toExpr(that)));
   }
   with(that) {
     return new _Expr(
@@ -240,6 +246,9 @@ var _Expr = class {
   at(index) {
     return this.get(`[${Number(index)}]`);
   }
+  includes(value) {
+    return _Expr.create(value).isIn(this);
+  }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
     const target = Target.Expr(this.expr, alias);
@@ -269,12 +278,6 @@ var _Expr = class {
 };
 var Expr = _Expr;
 __publicField(Expr, "NULL", toExpr(null));
-function unop(self, type) {
-  return new Expr(ExprData.UnOp(type, self.expr));
-}
-function binop(self, type, that) {
-  return new Expr(ExprData.BinOp(type, self.expr, toExpr(that)));
-}
 export {
   BinOpType,
   Expr,

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>;
+};

package/dist/define/Id.d.ts

@@ -1,3 +1,3 @@
-export type Id<T> = T extends {
-    id: any;
-} ? T['id'] : never;
+export type Id<T> = T extends {
+    id: any;
+} ? T['id'] : never;

package/dist/define/Index.d.ts

@@ -1,17 +1,17 @@
-import { Expr, ExprData } from './Expr';
-interface PartialIndexData {
-    on: Array<ExprData>;
-    unique?: boolean;
-    where?: ExprData;
-}
-export interface IndexData extends PartialIndexData {
-    name: string;
-}
-export declare class Index {
-    data: PartialIndexData;
-    constructor(data: PartialIndexData);
-    unique(): Index;
-    where(where: Expr<boolean>): Index;
-}
-export declare function index(...on: Array<Expr<any>>): Index;
-export {};
+import { Expr, ExprData } from './Expr';
+interface PartialIndexData {
+    on: Array<ExprData>;
+    unique?: boolean;
+    where?: ExprData;
+}
+export interface IndexData extends PartialIndexData {
+    name: string;
+}
+export declare class Index {
+    data: PartialIndexData;
+    constructor(data: PartialIndexData);
+    unique(): Index;
+    where(where: Expr<boolean>): Index;
+}
+export declare function index(...on: Array<Expr<any>>): Index;
+export {};

package/dist/define/Ops.d.ts

@@ -1,7 +1,9 @@
-import { Cursor } from './Cursor';
-import { Table } from './Table';
-export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
-export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
-export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
-export declare function create(...tables: Array<Table<any>>): Cursor.Batch;
+import { Cursor } from './Cursor';
+import { Selection } from './Selection';
+import { Table } from './Table';
+export declare function select<X extends Selection>(selection: X): Cursor.SelectMultiple<Selection.Infer<X>>;
+export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
+export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
+export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
+export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
+export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/define/Ops.js

@@ -4,6 +4,13 @@ import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
+function select(selection) {
+  return new Cursor.SelectMultiple(
+    Query.Select({
+      selection: ExprData.create(selection)
+    })
+  );
+}
 function from(source) {
   const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
   return new Cursor.SelectMultiple(
@@ -32,5 +39,6 @@ export {
   deleteFrom,
   from,
   insertInto,
+  select,
   update
 };

package/dist/define/OrderBy.d.ts

@@ -1,9 +1,9 @@
-import { ExprData } from './Expr';
-export declare enum OrderDirection {
-    Asc = "Asc",
-    Desc = "Desc"
-}
-export type OrderBy = {
-    expr: ExprData;
-    order: OrderDirection;
-};
+import { ExprData } from './Expr';
+export declare enum OrderDirection {
+    Asc = "Asc",
+    Desc = "Desc"
+}
+export type OrderBy = {
+    expr: ExprData;
+    order: OrderDirection;
+};

package/dist/define/Param.d.ts

@@ -1,15 +1,15 @@
-export declare enum ParamType {
-    Value = "Value",
-    Named = "Named"
-}
-export type ParamData = {
-    type: ParamType.Value;
-    value: any;
-} | {
-    type: ParamType.Named;
-    name: string;
-};
-export declare const ParamData: {
-    Value(value: any): ParamData;
-    Named(name: string): ParamData;
-};
+export declare enum ParamType {
+    Value = "Value",
+    Named = "Named"
+}
+export type ParamData = {
+    type: ParamType.Value;
+    value: any;
+} | {
+    type: ParamType.Named;
+    name: string;
+};
+export declare const ParamData: {
+    Value(value: any): ParamData;
+    Named(name: string): ParamData;
+};