rado 0.2.14 → 0.2.16

package/dist/define/Cursor.js

@@ -1,109 +1,109 @@
+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/define/Cursor.ts
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Selection } from "./Selection.js";
-import { createTable, table } from "./Table.js";
+import { Table, createTable } from "./Table.js";
 import { Target } from "./Target.js";
-var Cursor = class {
-  [Selection.__cursorType]() {
-    throw "assert";
-  }
+var QUERY = Symbol("Cursor.Query");
+var _Cursor = class {
+  [(Selection.CursorType, QUERY)];
   constructor(query) {
-    Object.defineProperty(this, "query", {
-      enumerable: false,
-      value: () => query
-    });
+    this[QUERY] = query;
   }
   static all(strings, ...params) {
-    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
-  }
-  query() {
-    throw new Error("Not implemented");
+    return new _Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
   }
   next(cursor) {
-    return new Cursor(
+    return new _Cursor(
       Query.Batch({
-        queries: [this.query(), cursor.query()]
+        queries: [this[QUERY], cursor[QUERY]]
       })
     );
   }
   on(driver) {
-    return driver.executeQuery(this.query());
+    return driver.executeQuery(this[QUERY]);
   }
   toSql(driver, options = { forceInline: true }) {
-    return driver.formatter.compile(this.query(), options).sql;
+    return driver.formatter.compile(this[QUERY], options).sql;
   }
   toJSON() {
-    return this.query();
+    return this[QUERY];
   }
 };
+var Cursor = _Cursor;
+__publicField(Cursor, "Query", QUERY);
 function addWhere(query, where) {
   const conditions = where.slice();
   if (query.where)
     conditions.push(new Expr(query.where));
   return {
     ...query,
-    where: Expr.and(...conditions).expr
+    where: Expr.and(...conditions)[Expr.Data]
   };
 }
 ((Cursor2) => {
   class Delete extends Cursor2 {
     query() {
-      return super.query();
+      return super[QUERY];
     }
     where(...where) {
-      return new Delete(addWhere(this.query(), where));
+      return new Delete(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new Delete({ ...this.query(), limit });
+      return new Delete({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new Delete({ ...this.query(), offset });
+      return new Delete({ ...this[QUERY], offset });
     }
   }
   Cursor2.Delete = Delete;
-  class Update extends Cursor2 {
-    query() {
-      return super.query();
-    }
+  const _Update = class extends Cursor2 {
     set(set) {
-      return new Update({ ...this.query(), set });
+      return new _Update({ ...this[QUERY], set });
     }
     where(...where) {
-      return new Update(addWhere(this.query(), where));
+      return new _Update(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new Update({ ...this.query(), limit });
+      return new _Update({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new Update({ ...this.query(), offset });
+      return new _Update({ ...this[QUERY], offset });
     }
-  }
+  };
+  let Update = _Update;
+  QUERY;
   Cursor2.Update = Update;
   class InsertValuesReturning extends Cursor2 {
   }
   Cursor2.InsertValuesReturning = InsertValuesReturning;
   class Inserted extends Cursor2 {
-    query() {
-      return super.query();
+    constructor(query) {
+      super(query);
     }
     returning(selection) {
       return new InsertValuesReturning(
-        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
+        Query.Insert({ ...this[QUERY], selection: ExprData.create(selection) })
       );
     }
   }
+  QUERY;
   Cursor2.Inserted = Inserted;
   class Insert {
     constructor(into) {
       this.into = into;
     }
     selection(query) {
-      return new Inserted(
-        Query.Insert({ into: this.into, select: query.query() })
-      );
+      return new Inserted(Query.Insert({ into: this.into, select: query[QUERY] }));
     }
     values(...data) {
       return new Inserted(Query.Insert({ into: this.into, data }));
@@ -111,9 +111,9 @@ function addWhere(query, where) {
   }
   Cursor2.Insert = Insert;
   class CreateTable extends Cursor2 {
-    constructor(table2) {
-      super(Schema.create(table2));
-      this.table = table2;
+    constructor(table) {
+      super(Schema.create(table));
+      this.table = table;
     }
   }
   Cursor2.CreateTable = CreateTable;
@@ -122,21 +122,19 @@ function addWhere(query, where) {
       super(Query.Batch({ queries }));
       this.queries = queries;
     }
-    query() {
-      return super.query();
-    }
     next(cursor) {
       return new Cursor2(
         Query.Batch({
-          queries: [...this.query().queries, cursor.query()]
+          queries: [...this[QUERY].queries, cursor[QUERY]]
         })
       );
     }
   }
+  QUERY;
   Cursor2.Batch = Batch;
   function joinTarget(joinType, query, to, on) {
-    const toQuery = to instanceof Cursor2 ? to.query() : void 0;
-    const target = toQuery ? toQuery.from : Target.Table(to[table.data]);
+    const toQuery = to instanceof Cursor2 ? to[QUERY] : void 0;
+    const target = toQuery ? toQuery.from : Target.Table(to[Table.Data]);
     if (!query.from || !target)
       throw new Error("No from clause");
     const conditions = [...on];
@@ -149,22 +147,22 @@ function addWhere(query, where) {
       query.from,
       target,
       joinType,
-      Expr.and(...conditions).expr
+      Expr.and(...conditions)[Expr.Data]
     );
   }
   class SelectMultiple extends Cursor2 {
-    query() {
-      return super.query();
+    constructor(query) {
+      super(query);
     }
     leftJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectMultiple({
         ...query,
         from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectMultiple({
         ...query,
         from: joinTarget("inner", query, that, on)
@@ -172,20 +170,20 @@ function addWhere(query, where) {
     }
     select(selection) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         selection: ExprData.create(selection)
       });
     }
     count() {
       return new SelectSingle({
-        ...this.query(),
-        selection: Functions.count().expr,
+        ...this[QUERY],
+        selection: Functions.count()[Expr.Data],
         singleResult: true
       });
     }
     orderBy(...orderBy) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         orderBy: orderBy.map((e) => {
           return Expr.isExpr(e) ? e.asc() : e;
         })
@@ -193,45 +191,45 @@ function addWhere(query, where) {
     }
     groupBy(...groupBy) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         groupBy: groupBy.map(ExprData.create)
       });
     }
     first() {
-      return new SelectSingle({ ...this.query(), singleResult: true });
+      return new SelectSingle({ ...this[QUERY], singleResult: true });
     }
     sure() {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         singleResult: true,
         validate: true
       });
     }
     where(...where) {
-      return new SelectMultiple(addWhere(this.query(), where));
+      return new SelectMultiple(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new SelectMultiple({ ...this.query(), limit });
+      return new SelectMultiple({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new SelectMultiple({ ...this.query(), offset });
+      return new SelectMultiple({ ...this[QUERY], offset });
     }
-    [Expr.toExpr]() {
-      return new Expr(ExprData.Query(this.query()));
+    [(QUERY, Expr.ToExpr)]() {
+      return new Expr(ExprData.Query(this[QUERY]));
     }
   }
   Cursor2.SelectMultiple = SelectMultiple;
   class TableSelect extends SelectMultiple {
-    constructor(table2, conditions = []) {
-      const target = Target.Table(table2);
+    constructor(table, conditions = []) {
+      const target = Target.Table(table);
       super(
         Query.Select({
           from: target,
           selection: ExprData.Row(target),
-          where: Expr.and(...conditions).expr
+          where: Expr.and(...conditions)[Expr.Data]
         })
       );
-      this.table = table2;
+      this.table = table;
     }
     as(alias) {
       return createTable({ ...this.table, alias });
@@ -241,7 +239,7 @@ function addWhere(query, where) {
     }
     insertSelect(query) {
       return new Cursor2.Inserted(
-        Query.Insert({ into: this.table, select: query.query() })
+        Query.Insert({ into: this.table, select: query[QUERY] })
       );
     }
     insertOne(record) {
@@ -261,7 +259,7 @@ function addWhere(query, where) {
       return new Cursor2.Update(
         Query.Update({
           table: this.table,
-          where: this.query().where
+          where: this[QUERY].where
         })
       ).set(data);
     }
@@ -269,7 +267,7 @@ function addWhere(query, where) {
       return new Cursor2.Delete(
         Query.Delete({
           table: this.table,
-          where: this.query().where
+          where: this[QUERY].where
         })
       );
     }
@@ -279,20 +277,21 @@ function addWhere(query, where) {
       );
     }
   }
+  QUERY;
   Cursor2.TableSelect = TableSelect;
   class SelectSingle extends Cursor2 {
-    query() {
-      return super.query();
+    constructor(query) {
+      super(query);
     }
     leftJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectSingle({
         ...query,
         from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectSingle({
         ...query,
         from: joinTarget("inner", query, that, on)
@@ -300,36 +299,36 @@ function addWhere(query, where) {
     }
     select(selection) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         selection: ExprData.create(selection)
       });
     }
     orderBy(...orderBy) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         orderBy
       });
     }
     groupBy(...groupBy) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         groupBy: groupBy.map(ExprData.create)
       });
     }
     where(...where) {
-      return new SelectSingle(addWhere(this.query(), where));
+      return new SelectSingle(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new SelectSingle({ ...this.query(), limit });
+      return new SelectSingle({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new SelectSingle({ ...this.query(), offset });
+      return new SelectSingle({ ...this[QUERY], offset });
     }
     all() {
-      return new SelectMultiple({ ...this.query(), singleResult: false });
+      return new SelectMultiple({ ...this[QUERY], singleResult: false });
     }
-    [Expr.toExpr]() {
-      return new Expr(ExprData.Query(this.query()));
+    [(QUERY, Expr.ToExpr)]() {
+      return new Expr(ExprData.Query(this[QUERY]));
     }
   }
   Cursor2.SelectSingle = SelectSingle;

package/dist/define/Expr.d.ts

@@ -5,6 +5,9 @@ import { ParamData } from './Param';
 import { Query } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
+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"
@@ -109,41 +112,38 @@ export declare namespace 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;
-};
+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;
+    function create(input: any): ExprData;
+}
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
-declare const isExpr: unique symbol;
 export declare class Expr<T> {
-    expr: ExprData;
-    static NULL: Expr<null>;
-    static toExpr: symbol;
-    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>;
-    static isExpr<T>(input: any): input is Expr<T>;
     constructor(expr: ExprData);
-    [isExpr]: boolean;
+    [DATA]: ExprData;
+    [IS_EXPR]: boolean;
     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>;
+    isConstant(value: T): boolean;
     isNot(that: EV<T>): Expr<boolean>;
     isNull(): Expr<boolean>;
     isNotNull(): Expr<boolean>;
@@ -163,6 +163,13 @@ export declare class Expr<T> {
     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>;
+    /**
+     * Dynamic expressions allow accessing runtime fields of JSON properties
+     * through a Proxy.
+     *
+     * Expr.value({a: {b: 1}}).dynamic().a.b.is(1) // true
+     **/
+    dynamic<X = T>(...path: Array<string>): Fields<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>>;
@@ -171,8 +178,14 @@ export declare class Expr<T> {
     get<T>(name: string): Expr<T>;
 }
 export declare namespace Expr {
-    type Record<T> = Expr<T> & {
-        [K in keyof T]: Expr<T[K]>;
-    };
+    const NULL: Expr<null>;
+    const Data: typeof DATA;
+    const IsExpr: typeof IS_EXPR;
+    const ToExpr: typeof TO_EXPR;
+    function value<T>(value: T): Expr<T>;
+    function create<T>(input: EV<T>): Expr<T>;
+    function and(...conditions: Array<EV<boolean>>): Expr<boolean>;
+    function or(...conditions: Array<EV<boolean>>): Expr<boolean>;
+    function isExpr<T>(input: any): input is Expr<T>;
 }
 export {};