rado 0.2.21 → 0.2.22

package/dist/define/Column.js

@@ -1,8 +1,8 @@
 // src/define/Column.ts
 import { Callable } from "../util/Callable.js";
 import { Expr, ExprData } from "./Expr.js";
-var DATA = Symbol("DATA");
-var TYPE = Symbol("tYPE");
+var DATA = Symbol("Column.Data");
+var TYPE = Symbol("Column.Type");
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
   ColumnType2["Integer"] = "Integer";
@@ -17,7 +17,7 @@ var Column;
   Column2.Type = TYPE;
 })(Column || (Column = {}));
 var ValueColumn = class extends Callable {
-  [(TYPE, DATA)];
+  [DATA];
   constructor(data) {
     super(() => this);
     this[DATA] = data;
@@ -63,7 +63,7 @@ var PrimaryColumn = class extends ValueColumn {
   [Column.IsPrimary];
 };
 var ObjectColumn = class extends Callable {
-  [(TYPE, DATA)];
+  [DATA];
   constructor(data) {
     super(() => this);
     this[DATA] = data;

package/dist/define/Expr.d.ts

@@ -1,13 +1,12 @@
-import { Cursor } from './Cursor';
 import { Fields } from './Fields';
 import { OrderBy } from './OrderBy';
 import { ParamData } from './Param';
-import { Query } from './Query';
+import { Query, QueryData } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
+declare const DATA: unique symbol;
 declare const TO_EXPR: unique symbol;
 declare const IS_EXPR: unique symbol;
-declare const DATA: unique symbol;
 export declare enum UnOpType {
     Not = "Not",
     IsNull = "IsNull"
@@ -34,101 +33,87 @@ export declare enum BinOpType {
     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"
+    UnOp = "ExprData.UnOp",
+    BinOp = "ExprData.BinOp",
+    Field = "ExprData.Field",
+    Param = "ExprData.Param",
+    Call = "ExprData.Call",
+    Query = "ExprData.Query",
+    Record = "ExprData.Record",
+    Row = "ExprData.Row",
+    Map = "ExprData.Map",
+    Filter = "ExprData.Filter",
+    Merge = "ExprData.Merge"
 }
-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 type ExprData = ExprData.UnOp | ExprData.BinOp | ExprData.Field | ExprData.Param | ExprData.Call | ExprData.Query | ExprData.Record | ExprData.Merge | ExprData.Row | ExprData.Map | ExprData.Filter;
 export declare namespace ExprData {
-    type UnOp = {
-        type: ExprType.UnOp;
+    class UnOp {
         op: UnOpType;
         expr: ExprData;
-    };
-    type BinOp = {
-        type: ExprType.BinOp;
+        type: ExprType.UnOp;
+        constructor(op: UnOpType, expr: ExprData);
+    }
+    class BinOp {
         op: BinOpType;
         a: ExprData;
         b: ExprData;
-    };
-    type Field = {
-        type: ExprType.Field;
+        type: ExprType.BinOp;
+        constructor(op: BinOpType, a: ExprData, b: ExprData);
+    }
+    class Field {
         expr: ExprData;
         field: string;
-    };
-    type Param = {
-        type: ExprType.Param;
+        type: ExprType.Field;
+        constructor(expr: ExprData, field: string);
+    }
+    class Param {
         param: ParamData;
-    };
-    type Call = {
-        type: ExprType.Call;
+        type: ExprType.Param;
+        constructor(param: ParamData);
+    }
+    class Call {
         method: string;
         params: Array<ExprData>;
-    };
-    type Query = {
+        type: ExprType.Call;
+        constructor(method: string, params: Array<ExprData>);
+    }
+    class Query {
+        query: QueryData.Select;
         type: ExprType.Query;
-        query: Query.Select;
-    };
-    type Record = {
-        type: ExprType.Record;
+        constructor(query: QueryData.Select);
+    }
+    class Record {
         fields: {
             [key: string]: ExprData;
         };
-    };
-    type Merge = {
-        type: ExprType.Merge;
+        type: ExprType.Record;
+        constructor(fields: {
+            [key: string]: ExprData;
+        });
+    }
+    class Merge {
         a: ExprData;
         b: ExprData;
-    };
-    type Row = {
-        type: ExprType.Row;
+        type: ExprType.Merge;
+        constructor(a: ExprData, b: ExprData);
+    }
+    class Row {
         target: Target;
-    };
-    type Map = {
-        type: ExprType.Map;
+        type: ExprType.Row;
+        constructor(target: Target);
+    }
+    class Map {
         target: Target;
         result: ExprData;
-    };
-    type Filter = {
-        type: ExprType.Filter;
+        type: ExprType.Map;
+        constructor(target: Target, result: ExprData);
+    }
+    class Filter {
         target: Target;
         condition: ExprData;
-    };
-    type Case = {
-        type: ExprType.Case;
-        expr: ExprData;
-        cases: {
-            [key: string]: ExprData;
-        };
-        defaultCase?: ExprData;
-    };
-}
-export declare namespace ExprData {
-    function UnOp(op: UnOpType, expr: ExprData): ExprData;
-    function BinOp(op: BinOpType, a: ExprData, b: ExprData): ExprData;
-    function Field(expr: ExprData, field: string): ExprData;
-    function Param(param: ParamData): ExprData;
-    function Call(method: string, params: Array<ExprData>): ExprData;
-    function Query(query: Query.Select): ExprData;
-    function Record(fields: {
-        [key: string]: ExprData;
-    }): ExprData;
-    function Merge(a: ExprData, b: ExprData): ExprData;
-    function Row(target: Target): ExprData;
-    function Map(target: Target, result: ExprData): ExprData;
-    function Filter(target: Target, condition: ExprData): ExprData;
-    function Case(expr: ExprData, cases: {
-        [key: string]: ExprData;
-    }, defaultCase?: ExprData): ExprData;
+        type: ExprType.Filter;
+        constructor(target: Target, condition: ExprData);
+    }
     function create(input: any): ExprData;
 }
 /** Expression or value of type T */
@@ -142,13 +127,13 @@ export declare class Expr<T> {
     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>;
+    is(that: EV<T> | Query.SelectSingle<T>): Expr<boolean>;
     isConstant(value: T): 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>;
+    isIn(that: EV<Array<T>> | Query.SelectMultiple<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | Query.SelectMultiple<T>): Expr<boolean>;
     isGreater(that: EV<any>): Expr<boolean>;
     isGreaterOrEqual(that: EV<any>): Expr<boolean>;
     isLess(that: EV<any>): Expr<boolean>;
@@ -178,10 +163,10 @@ export declare class Expr<T> {
     get<T>(name: string): Expr<T>;
 }
 export declare namespace Expr {
-    const NULL: Expr<null>;
     const Data: typeof DATA;
     const IsExpr: typeof IS_EXPR;
     const ToExpr: typeof TO_EXPR;
+    const NULL: Expr<null>;
     function value<T>(value: T): Expr<T>;
     function create<T>(input: EV<T>): Expr<T>;
     function and(...conditions: Array<EV<boolean>>): Expr<boolean>;

package/dist/define/Expr.js

@@ -3,9 +3,9 @@ import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
 var { fromEntries, entries } = Object;
+var DATA = Symbol("Expr.Data");
 var TO_EXPR = Symbol("Expr.ToExpr");
 var IS_EXPR = Symbol("Expr.IsExpr");
-var DATA = Symbol("Expr.Data");
 var UnOpType = /* @__PURE__ */ ((UnOpType2) => {
   UnOpType2["Not"] = "Not";
   UnOpType2["IsNull"] = "IsNull";
@@ -34,84 +34,120 @@ var BinOpType = /* @__PURE__ */ ((BinOpType2) => {
   return BinOpType2;
 })(BinOpType || {});
 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";
+  ExprType2["UnOp"] = "ExprData.UnOp";
+  ExprType2["BinOp"] = "ExprData.BinOp";
+  ExprType2["Field"] = "ExprData.Field";
+  ExprType2["Param"] = "ExprData.Param";
+  ExprType2["Call"] = "ExprData.Call";
+  ExprType2["Query"] = "ExprData.Query";
+  ExprType2["Record"] = "ExprData.Record";
+  ExprType2["Row"] = "ExprData.Row";
+  ExprType2["Map"] = "ExprData.Map";
+  ExprType2["Filter"] = "ExprData.Filter";
+  ExprType2["Merge"] = "ExprData.Merge";
   return ExprType2;
 })(ExprType || {});
 var ExprData;
 ((ExprData2) => {
-  function UnOp(op, expr) {
-    return { type: "UnOp" /* UnOp */, op, expr };
+  class UnOp {
+    constructor(op, expr) {
+      this.op = op;
+      this.expr = expr;
+    }
+    type = "ExprData.UnOp" /* UnOp */;
   }
   ExprData2.UnOp = UnOp;
-  function BinOp(op, a, b) {
-    return { type: "BinOp" /* BinOp */, op, a, b };
+  class BinOp {
+    constructor(op, a, b) {
+      this.op = op;
+      this.a = a;
+      this.b = b;
+    }
+    type = "ExprData.BinOp" /* BinOp */;
   }
   ExprData2.BinOp = BinOp;
-  function Field(expr, field) {
-    return { type: "Field" /* Field */, expr, field };
+  class Field {
+    constructor(expr, field) {
+      this.expr = expr;
+      this.field = field;
+    }
+    type = "ExprData.Field" /* Field */;
   }
   ExprData2.Field = Field;
-  function Param(param) {
-    return { type: "Param" /* Param */, param };
+  class Param {
+    constructor(param) {
+      this.param = param;
+    }
+    type = "ExprData.Param" /* Param */;
   }
   ExprData2.Param = Param;
-  function Call(method, params) {
-    return { type: "Call" /* Call */, method, params };
+  class Call {
+    constructor(method, params) {
+      this.method = method;
+      this.params = params;
+    }
+    type = "ExprData.Call" /* Call */;
   }
   ExprData2.Call = Call;
-  function Query(query) {
-    return { type: "Query" /* Query */, query };
+  class Query {
+    constructor(query) {
+      this.query = query;
+    }
+    type = "ExprData.Query" /* Query */;
   }
   ExprData2.Query = Query;
-  function Record(fields) {
-    return { type: "Record" /* Record */, fields };
+  class Record {
+    constructor(fields) {
+      this.fields = fields;
+    }
+    type = "ExprData.Record" /* Record */;
   }
   ExprData2.Record = Record;
-  function Merge(a, b) {
-    return { type: "Merge" /* Merge */, a, b };
+  class Merge {
+    constructor(a, b) {
+      this.a = a;
+      this.b = b;
+    }
+    type = "ExprData.Merge" /* Merge */;
   }
   ExprData2.Merge = Merge;
-  function Row(target) {
-    return { type: "Row" /* Row */, target };
+  class Row {
+    constructor(target) {
+      this.target = target;
+    }
+    type = "ExprData.Row" /* Row */;
   }
   ExprData2.Row = Row;
-  function Map(target, result) {
-    return { type: "Map" /* Map */, target, result };
+  class Map {
+    constructor(target, result) {
+      this.target = target;
+      this.result = result;
+    }
+    type = "ExprData.Map" /* Map */;
   }
   ExprData2.Map = Map;
-  function Filter(target, condition) {
-    return { type: "Filter" /* Filter */, target, condition };
+  class Filter {
+    constructor(target, condition) {
+      this.target = target;
+      this.condition = condition;
+    }
+    type = "ExprData.Filter" /* Filter */;
   }
   ExprData2.Filter = Filter;
-  function Case(expr, cases, defaultCase) {
-    return { type: "Case" /* Case */, expr, cases, defaultCase };
-  }
-  ExprData2.Case = Case;
   function create(input) {
     if (input === null || input === void 0)
-      return ExprData2.Param(ParamData.Value(null));
+      return new ExprData2.Param(new ParamData.Value(null));
     if (input && (typeof input === "function" || typeof input === "object") && input[TO_EXPR])
       input = input[TO_EXPR]();
     if (Expr.isExpr(input))
       return input[DATA];
     if (input && typeof input === "object" && !Array.isArray(input))
-      return ExprData2.Record(
+      return new ExprData2.Record(
         fromEntries(
           entries(input).map(([key, value]) => [key, ExprData2.create(value)])
         )
       );
-    return ExprData2.Param(ParamData.Value(input));
+    return new ExprData2.Param(new ParamData.Value(input));
   }
   ExprData2.create = create;
 })(ExprData || (ExprData = {}));
@@ -128,7 +164,7 @@ var Expr = class {
     return { expr: this[DATA], order: OrderDirection.Desc };
   }
   not() {
-    return new Expr(ExprData.UnOp("Not" /* Not */, this[DATA]));
+    return new Expr(new ExprData.UnOp("Not" /* Not */, this[DATA]));
   }
   or(that) {
     const a = this;
@@ -137,7 +173,7 @@ var Expr = class {
       return b;
     if (a.isConstant(true) || b.isConstant(false))
       return this;
-    return new Expr(ExprData.BinOp("Or" /* Or */, a[DATA], b[DATA]));
+    return new Expr(new ExprData.BinOp("Or" /* Or */, a[DATA], b[DATA]));
   }
   and(that) {
     const a = this;
@@ -146,21 +182,22 @@ var Expr = class {
       return this;
     if (a.isConstant(true) || b.isConstant(false))
       return b;
-    return new Expr(ExprData.BinOp("And" /* And */, a[DATA], b[DATA]));
+    return new Expr(new ExprData.BinOp("And" /* And */, a[DATA], b[DATA]));
   }
   is(that) {
     if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNull();
     return new Expr(
-      ExprData.BinOp("Equals" /* Equals */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Equals" /* Equals */, this[DATA], ExprData.create(that))
     );
   }
   isConstant(value) {
     switch (this[DATA].type) {
-      case "Param" /* Param */:
-        switch (this[DATA].param.type) {
+      case "ExprData.Param" /* Param */:
+        const param = this[DATA].param;
+        switch (param.type) {
           case ParamType.Value:
-            return this[DATA].param.value === value;
+            return param.value === value;
           default:
             return false;
         }
@@ -172,33 +209,33 @@ var Expr = class {
     if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNotNull();
     return new Expr(
-      ExprData.BinOp("NotEquals" /* NotEquals */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("NotEquals" /* NotEquals */, this[DATA], ExprData.create(that))
     );
   }
   isNull() {
-    return new Expr(ExprData.UnOp("IsNull" /* IsNull */, this[DATA]));
+    return new Expr(new ExprData.UnOp("IsNull" /* IsNull */, this[DATA]));
   }
   isNotNull() {
     return this.isNull().not();
   }
   isIn(that) {
     return new Expr(
-      ExprData.BinOp("In" /* In */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("In" /* In */, this[DATA], ExprData.create(that))
     );
   }
   isNotIn(that) {
     return new Expr(
-      ExprData.BinOp("NotIn" /* NotIn */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("NotIn" /* NotIn */, this[DATA], ExprData.create(that))
     );
   }
   isGreater(that) {
     return new Expr(
-      ExprData.BinOp("Greater" /* Greater */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Greater" /* Greater */, this[DATA], ExprData.create(that))
     );
   }
   isGreaterOrEqual(that) {
     return new Expr(
-      ExprData.BinOp(
+      new ExprData.BinOp(
         "GreaterOrEqual" /* GreaterOrEqual */,
         this[DATA],
         ExprData.create(that)
@@ -207,62 +244,66 @@ var Expr = class {
   }
   isLess(that) {
     return new Expr(
-      ExprData.BinOp("Less" /* Less */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Less" /* Less */, this[DATA], ExprData.create(that))
     );
   }
   isLessOrEqual(that) {
     return new Expr(
-      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "LessOrEqual" /* LessOrEqual */,
+        this[DATA],
+        ExprData.create(that)
+      )
     );
   }
   add(that) {
     return new Expr(
-      ExprData.BinOp("Add" /* Add */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Add" /* Add */, this[DATA], ExprData.create(that))
     );
   }
   substract(that) {
     return new Expr(
-      ExprData.BinOp("Subt" /* Subt */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Subt" /* Subt */, this[DATA], ExprData.create(that))
     );
   }
   multiply(that) {
     return new Expr(
-      ExprData.BinOp("Mult" /* Mult */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Mult" /* Mult */, this[DATA], ExprData.create(that))
     );
   }
   remainder(that) {
     return new Expr(
-      ExprData.BinOp("Mod" /* Mod */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Mod" /* Mod */, this[DATA], ExprData.create(that))
     );
   }
   divide(that) {
     return new Expr(
-      ExprData.BinOp("Div" /* Div */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Div" /* Div */, this[DATA], ExprData.create(that))
     );
   }
   concat(that) {
     return new Expr(
-      ExprData.BinOp("Concat" /* Concat */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Concat" /* Concat */, this[DATA], ExprData.create(that))
     );
   }
   like(that) {
     return new Expr(
-      ExprData.BinOp("Like" /* Like */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Like" /* Like */, this[DATA], ExprData.create(that))
     );
   }
   glob(that) {
     return new Expr(
-      ExprData.BinOp("Glob" /* Glob */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Glob" /* Glob */, this[DATA], ExprData.create(that))
     );
   }
   match(that) {
     return new Expr(
-      ExprData.BinOp("Match" /* Match */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Match" /* Match */, this[DATA], ExprData.create(that))
     );
   }
   with(that) {
     return new Expr(
-      ExprData.Merge(this[DATA], ExprData.create(that))
+      new ExprData.Merge(this[DATA], ExprData.create(that))
     );
   }
   /**
@@ -296,21 +337,21 @@ var Expr = class {
   }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this[DATA], alias);
+    const target = new Target.Expr(this[DATA], alias);
     return new Expr(
-      ExprData.Filter(
+      new ExprData.Filter(
         target,
-        ExprData.create(fn(new Expr(ExprData.Row(target)).dynamic()))
+        ExprData.create(fn(new Expr(new ExprData.Row(target)).dynamic()))
       )
     );
   }
   map(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this[DATA], alias);
+    const target = new Target.Expr(this[DATA], alias);
     return new Expr(
-      ExprData.Map(
+      new ExprData.Map(
         target,
-        ExprData.create(fn(new Expr(ExprData.Row(target)).dynamic()))
+        ExprData.create(fn(new Expr(new ExprData.Row(target)).dynamic()))
       )
     );
   }
@@ -318,16 +359,16 @@ var Expr = class {
     return this;
   }
   get(name) {
-    return new Expr(ExprData.Field(this[DATA], name));
+    return new Expr(new ExprData.Field(this[DATA], name));
   }
 };
 ((Expr2) => {
-  Expr2.NULL = create(null);
   Expr2.Data = DATA;
   Expr2.IsExpr = IS_EXPR;
   Expr2.ToExpr = TO_EXPR;
+  Expr2.NULL = create(null);
   function value(value2) {
-    return new Expr2(ExprData.Param(ParamData.Value(value2)));
+    return new Expr2(new ExprData.Param(new ParamData.Value(value2)));
   }
   Expr2.value = value;
   function create(input) {

package/dist/define/Functions.js

@@ -2,7 +2,7 @@
 import { Expr, ExprData } from "./Expr.js";
 function get(_, method) {
   return (...args) => {
-    return new Expr(ExprData.Call(method, args.map(ExprData.create)));
+    return new Expr(new ExprData.Call(method, args.map(ExprData.create)));
   };
 }
 var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });

package/dist/define/Ops.d.ts

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