rado 0.1.52 → 0.1.53

package/dist/lib/Driver.d.ts

@@ -1,110 +1,110 @@
-import { Cursor } from '../define/Cursor';
-import { Expr } from '../define/Expr';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Table } from '../define/Table';
-import { Formatter } from './Formatter';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
-    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-type ParamTypes<Params extends [...any[]]> = {
-    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
-} & {
-    length: Params['length'];
-};
-interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
-    (strings: TemplateStringsArray, ...values: any[]): any;
-}
-declare abstract class SyncDriver extends DriverBase {
-    transactionId: number;
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
-    migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
-    get<T>(cursor: Cursor<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
-    transaction<T>(run: (query: SyncDriver) => T): T;
-    toAsync(): SyncWrapper;
-}
-interface SyncPreparedStatement {
-    run(params?: Array<any>): {
-        rowsAffected: number;
-    };
-    iterate<T>(params?: Array<any>): Iterable<T>;
-    all<T>(params?: Array<any>): Array<T>;
-    get<T>(params?: Array<any>): T;
-    execute(params?: Array<any>): void;
-}
-interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
-    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-}
-declare abstract class AsyncDriver extends DriverBase {
-    transactionId: number;
-    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
-    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Cursor<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Cursor<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
-    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
-}
-declare class SyncWrapper extends AsyncDriver {
-    private sync;
-    lock: Promise<void> | undefined;
-    constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-}
-interface AsyncPreparedStatement {
-    run(params?: Array<any>): Promise<{
-        rowsAffected: number;
-    }>;
-    iterate<T>(params?: Array<any>): AsyncIterable<T>;
-    all<T>(params?: Array<any>): Promise<Array<T>>;
-    get<T>(params?: Array<any>): Promise<T>;
-    execute(params?: Array<any>): Promise<void>;
-}
-export type Driver = SyncDriver | AsyncDriver;
-export declare namespace Driver {
-    type Sync = SyncDriver;
-    const Sync: typeof SyncDriver;
-    namespace Sync {
-        type PreparedStatement = SyncPreparedStatement;
-    }
-    type Async = AsyncDriver;
-    const Async: typeof AsyncDriver;
-    namespace Async {
-        type PreparedStatement = AsyncPreparedStatement;
-    }
-}
-export {};
+import { Cursor } from '../define/Cursor';
+import { Expr } from '../define/Expr';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Table } from '../define/Table';
+import { Formatter } from './Formatter';
+import { Statement } from './Statement';
+declare class Callable extends Function {
+    constructor(fn: Function);
+}
+declare abstract class DriverBase extends Callable {
+    formatter: Formatter;
+    constructor(formatter: Formatter);
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+type ParamTypes<Params extends [...any[]]> = {
+    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
+} & {
+    length: Params['length'];
+};
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): T;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
+    get<T>(cursor: Cursor<T>): T;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface SyncPreparedStatement {
+    run(params?: Array<any>): {
+        rowsAffected: number;
+    };
+    iterate<T>(params?: Array<any>): Iterable<T>;
+    all<T>(params?: Array<any>): Array<T>;
+    get<T>(params?: Array<any>): T;
+    execute(params?: Array<any>): void;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
+interface AsyncPreparedStatement {
+    run(params?: Array<any>): Promise<{
+        rowsAffected: number;
+    }>;
+    iterate<T>(params?: Array<any>): AsyncIterable<T>;
+    all<T>(params?: Array<any>): Promise<Array<T>>;
+    get<T>(params?: Array<any>): Promise<T>;
+    execute(params?: Array<any>): Promise<void>;
+}
+export type Driver = SyncDriver | AsyncDriver;
+export declare namespace Driver {
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    namespace Sync {
+        type PreparedStatement = SyncPreparedStatement;
+    }
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
+    namespace Async {
+        type PreparedStatement = AsyncPreparedStatement;
+    }
+}
+export {};

package/dist/lib/Expr.d.ts

@@ -0,0 +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>;
+    isIn(that: EV<Array<T>> | Cursor<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | Cursor<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/lib/Expr.js

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/lib/Expr.ts
+import { OrderDirection } from "./OrderBy.js";
+import { ParamData, ParamType } from "./Param.js";
+import { Target } from "./Target.js";
+var UnOp = /* @__PURE__ */ ((UnOp2) => {
+  UnOp2["Not"] = "Not";
+  UnOp2["IsNull"] = "IsNull";
+  return UnOp2;
+})(UnOp || {});
+var BinOp = /* @__PURE__ */ ((BinOp2) => {
+  BinOp2["Add"] = "Add";
+  BinOp2["Subt"] = "Subt";
+  BinOp2["Mult"] = "Mult";
+  BinOp2["Mod"] = "Mod";
+  BinOp2["Div"] = "Div";
+  BinOp2["Greater"] = "Greater";
+  BinOp2["GreaterOrEqual"] = "GreaterOrEqual";
+  BinOp2["Less"] = "Less";
+  BinOp2["LessOrEqual"] = "LessOrEqual";
+  BinOp2["Equals"] = "Equals";
+  BinOp2["NotEquals"] = "NotEquals";
+  BinOp2["And"] = "And";
+  BinOp2["Or"] = "Or";
+  BinOp2["Like"] = "Like";
+  BinOp2["Glob"] = "Glob";
+  BinOp2["Match"] = "Match";
+  BinOp2["In"] = "In";
+  BinOp2["NotIn"] = "NotIn";
+  BinOp2["Concat"] = "Concat";
+  return BinOp2;
+})(BinOp || {});
+var ExprType = /* @__PURE__ */ ((ExprType2) => {
+  ExprType2["UnOp"] = "UnOp";
+  ExprType2["BinOp"] = "BinOp";
+  ExprType2["Field"] = "Field";
+  ExprType2["Param"] = "Param";
+  ExprType2["Call"] = "Call";
+  ExprType2["Query"] = "Query";
+  ExprType2["Record"] = "Record";
+  ExprType2["Row"] = "Row";
+  ExprType2["Map"] = "Map";
+  ExprType2["Filter"] = "Filter";
+  ExprType2["Merge"] = "Merge";
+  ExprType2["Case"] = "Case";
+  return ExprType2;
+})(ExprType || {});
+var ExprData = {
+  UnOp(op, expr) {
+    return { type: "UnOp" /* UnOp */, op, expr };
+  },
+  BinOp(op, a, b) {
+    return { type: "BinOp" /* BinOp */, op, a, b };
+  },
+  Field(expr, field) {
+    return { type: "Field" /* Field */, expr, field };
+  },
+  Param(param) {
+    return { type: "Param" /* Param */, param };
+  },
+  Call(method, params) {
+    return { type: "Call" /* Call */, method, params };
+  },
+  Query(query) {
+    return { type: "Query" /* Query */, query };
+  },
+  Record(fields) {
+    return { type: "Record" /* Record */, fields };
+  },
+  Merge(a, b) {
+    return { type: "Merge" /* Merge */, a, b };
+  },
+  Row(target) {
+    return { type: "Row" /* Row */, target };
+  },
+  Map(target, result) {
+    return { type: "Map" /* Map */, target, result };
+  },
+  Filter(target, condition) {
+    return { type: "Filter" /* Filter */, target, condition };
+  },
+  Case(expr, cases, defaultCase) {
+    return { type: "Case" /* Case */, expr, cases, defaultCase };
+  },
+  create(input) {
+    if (input === null || input === void 0)
+      return ExprData.Param(ParamData.Value(null));
+    if (input && typeof input === "object" && typeof input.toExpr === "function")
+      input = input.toExpr();
+    if (input instanceof Expr)
+      return input.expr;
+    if (input && typeof input === "object" && !Array.isArray(input))
+      return ExprData.Record(
+        Object.fromEntries(
+          Object.entries(input).map(([key, value]) => [
+            key,
+            ExprData.create(value)
+          ])
+        )
+      );
+    return ExprData.Param(ParamData.Value(input));
+  }
+};
+var toExpr = ExprData.create;
+function isConstant(e, value) {
+  switch (e.type) {
+    case "Param" /* Param */:
+      switch (e.param.type) {
+        case ParamType.Value:
+          return e.param.value == value;
+        default:
+          return false;
+      }
+    default:
+      return false;
+  }
+}
+var _Expr = class {
+  constructor(expr) {
+    this.expr = expr;
+    return new Proxy(this, {
+      get(target, key) {
+        return key in target ? target[key] : target.get(key);
+      }
+    });
+  }
+  static value(value) {
+    return new _Expr(ExprData.Param(ParamData.Value(value)));
+  }
+  static create(input) {
+    if (input instanceof _Expr)
+      return input;
+    return new _Expr(ExprData.create(input));
+  }
+  static and(...conditions) {
+    return conditions.map(_Expr.create).reduce((condition, expr) => condition.and(expr), _Expr.value(true));
+  }
+  static or(...conditions) {
+    return conditions.map(_Expr.create).reduce((condition, expr) => condition.or(expr), _Expr.value(false));
+  }
+  asc() {
+    return { expr: this.expr, order: OrderDirection.Asc };
+  }
+  desc() {
+    return { expr: this.expr, order: OrderDirection.Desc };
+  }
+  not() {
+    return unop(this, "Not" /* Not */);
+  }
+  or(that) {
+    const a = this.expr;
+    const b = toExpr(that);
+    if (isConstant(b, true) || isConstant(a, false))
+      return new _Expr(b);
+    if (isConstant(a, true) || isConstant(b, false))
+      return this;
+    return new _Expr(ExprData.BinOp("Or" /* Or */, a, b));
+  }
+  and(that) {
+    const a = this.expr;
+    const b = toExpr(that);
+    if (isConstant(b, true) || isConstant(a, false))
+      return this;
+    if (isConstant(a, true) || isConstant(b, false))
+      return new _Expr(b);
+    return new _Expr(ExprData.BinOp("And" /* And */, a, b));
+  }
+  isNull() {
+    return unop(this, "IsNull" /* IsNull */);
+  }
+  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);
+  }
+  is(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNull();
+    return binop(this, "Equals" /* Equals */, that);
+  }
+  isIn(that) {
+    return binop(this, "In" /* In */, that);
+  }
+  isNotIn(that) {
+    return binop(this, "NotIn" /* NotIn */, that);
+  }
+  add(that) {
+    return binop(this, "Add" /* Add */, that);
+  }
+  substract(that) {
+    return binop(this, "Subt" /* Subt */, that);
+  }
+  multiply(that) {
+    return binop(this, "Mult" /* Mult */, that);
+  }
+  remainder(that) {
+    return binop(this, "Mod" /* Mod */, 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);
+  }
+  concat(that) {
+    return binop(this, "Concat" /* Concat */, that);
+  }
+  like(that) {
+    return binop(this, "Like" /* Like */, that);
+  }
+  glob(that) {
+    return binop(this, "Glob" /* Glob */, that);
+  }
+  match(that) {
+    return binop(this, "Match" /* Match */, that);
+  }
+  with(that) {
+    return new _Expr(
+      ExprData.Merge(this.expr, ExprData.create(that))
+    );
+  }
+  at(index) {
+    return this.get(`[${Number(index)}]`);
+  }
+  filter(fn) {
+    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
+    const target = Target.Each(this.expr, alias);
+    return new _Expr(
+      ExprData.Filter(
+        target,
+        ExprData.create(fn(new _Expr(ExprData.Row(target))))
+      )
+    );
+  }
+  map(fn) {
+    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
+    const target = Target.Each(this.expr, alias);
+    return new _Expr(
+      ExprData.Map(
+        target,
+        ExprData.create(fn(new _Expr(ExprData.Row(target))))
+      )
+    );
+  }
+  sure() {
+    return this;
+  }
+  get(name) {
+    return new _Expr(ExprData.Field(this.expr, name));
+  }
+};
+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 {
+  BinOp,
+  Expr,
+  ExprData,
+  ExprType,
+  UnOp
+};

package/dist/lib/Fields.d.ts

@@ -0,0 +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 {};