rado 0.2.13 → 0.2.15

package/dist/define/Expr.js

@@ -1,15 +1,11 @@
-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/Expr.ts
 import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
-var { fromEntries, entries, getPrototypeOf } = Object;
+var { fromEntries, entries } = Object;
+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";
@@ -52,237 +48,271 @@ var ExprType = /* @__PURE__ */ ((ExprType2) => {
   ExprType2["Case"] = "Case";
   return ExprType2;
 })(ExprType || {});
-var ExprData = {
-  UnOp(op, expr) {
+var ExprData;
+((ExprData2) => {
+  function UnOp(op, expr) {
     return { type: "UnOp" /* UnOp */, op, expr };
-  },
-  BinOp(op, a, b) {
+  }
+  ExprData2.UnOp = UnOp;
+  function BinOp(op, a, b) {
     return { type: "BinOp" /* BinOp */, op, a, b };
-  },
-  Field(expr, field) {
+  }
+  ExprData2.BinOp = BinOp;
+  function Field(expr, field) {
     return { type: "Field" /* Field */, expr, field };
-  },
-  Param(param) {
+  }
+  ExprData2.Field = Field;
+  function Param(param) {
     return { type: "Param" /* Param */, param };
-  },
-  Call(method, params) {
+  }
+  ExprData2.Param = Param;
+  function Call(method, params) {
     return { type: "Call" /* Call */, method, params };
-  },
-  Query(query) {
+  }
+  ExprData2.Call = Call;
+  function Query(query) {
     return { type: "Query" /* Query */, query };
-  },
-  Record(fields) {
+  }
+  ExprData2.Query = Query;
+  function Record(fields) {
     return { type: "Record" /* Record */, fields };
-  },
-  Merge(a, b) {
+  }
+  ExprData2.Record = Record;
+  function Merge(a, b) {
     return { type: "Merge" /* Merge */, a, b };
-  },
-  Row(target) {
+  }
+  ExprData2.Merge = Merge;
+  function Row(target) {
     return { type: "Row" /* Row */, target };
-  },
-  Map(target, result) {
+  }
+  ExprData2.Row = Row;
+  function Map(target, result) {
     return { type: "Map" /* Map */, target, result };
-  },
-  Filter(target, condition) {
+  }
+  ExprData2.Map = Map;
+  function Filter(target, condition) {
     return { type: "Filter" /* Filter */, target, condition };
-  },
-  Case(expr, cases, defaultCase) {
+  }
+  ExprData2.Filter = Filter;
+  function Case(expr, cases, defaultCase) {
     return { type: "Case" /* Case */, expr, cases, defaultCase };
-  },
-  create(input) {
+  }
+  ExprData2.Case = Case;
+  function create(input) {
     if (input === null || input === void 0)
-      return ExprData.Param(ParamData.Value(null));
-    if (input && (typeof input === "function" || typeof input === "object") && input[Expr.toExpr])
-      input = input[Expr.toExpr]();
-    if (input instanceof Expr)
-      return input.expr;
+      return ExprData2.Param(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 ExprData.Record(
+      return ExprData2.Record(
         fromEntries(
-          entries(input).map(([key, value]) => [key, ExprData.create(value)])
+          entries(input).map(([key, value]) => [key, ExprData2.create(value)])
         )
       );
-    return ExprData.Param(ParamData.Value(input));
+    return ExprData2.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;
-  }
-}
-function dotAccess(expr, path) {
-  return new Expr(ExprData.Field(expr.expr, path.join(".")));
-}
-function exprAccess(expr, ...path) {
-  return new Proxy(expr, {
-    apply(target, thisArg, args) {
-      const proto = getPrototypeOf(expr);
-      const method = path.pop();
-      const e = path.length > 0 ? dotAccess(expr, path) : expr;
-      return proto[method].apply(e, args);
-    },
-    get(_, key) {
-      const e = path.length > 0 ? dotAccess(expr, path) : expr;
-      if (key === "expr")
-        return e.expr;
-      if (typeof key !== "string")
-        return e[key];
-      return exprAccess(expr, ...path, key);
-    }
-  });
-}
-var callable = Function;
-var _Expr = class extends callable {
+  ExprData2.create = create;
+})(ExprData || (ExprData = {}));
+var Expr = class {
   constructor(expr) {
-    super();
-    this.expr = expr;
-    return exprAccess(this);
-  }
-  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));
+    this[DATA] = expr;
   }
+  [DATA];
+  [IS_EXPR] = true;
   asc() {
-    return { expr: this.expr, order: OrderDirection.Asc };
+    return { expr: this[DATA], order: OrderDirection.Asc };
   }
   desc() {
-    return { expr: this.expr, order: OrderDirection.Desc };
+    return { expr: this[DATA], order: OrderDirection.Desc };
   }
   not() {
-    return new _Expr(ExprData.UnOp("Not" /* Not */, this.expr));
+    return new Expr(ExprData.UnOp("Not" /* Not */, this[DATA]));
   }
   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))
+    const a = this;
+    const b = Expr.create(that);
+    if (b.isConstant(true) || a.isConstant(false))
+      return b;
+    if (a.isConstant(true) || b.isConstant(false))
       return this;
-    return new _Expr(ExprData.BinOp("Or" /* Or */, a, b));
+    return new Expr(ExprData.BinOp("Or" /* Or */, a[DATA], b[DATA]));
   }
   and(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
+    const a = this;
+    const b = Expr.create(that);
+    if (b.isConstant(true) || a.isConstant(false))
       return this;
-    if (isConstant(a, true) || isConstant(b, false))
-      return new _Expr(b);
-    return new _Expr(ExprData.BinOp("And" /* And */, a, b));
+    if (a.isConstant(true) || b.isConstant(false))
+      return b;
+    return new Expr(ExprData.BinOp("And" /* And */, a[DATA], b[DATA]));
   }
   is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+    if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNull();
-    return new _Expr(ExprData.BinOp("Equals" /* Equals */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Equals" /* Equals */, this[DATA], ExprData.create(that))
+    );
+  }
+  isConstant(value) {
+    switch (this[DATA].type) {
+      case "Param" /* Param */:
+        switch (this[DATA].param.type) {
+          case ParamType.Value:
+            return this[DATA].param.value === value;
+          default:
+            return false;
+        }
+      default:
+        return false;
+    }
   }
   isNot(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+    if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNotNull();
-    return new _Expr(
-      ExprData.BinOp("NotEquals" /* NotEquals */, this.expr, toExpr(that))
+    return new Expr(
+      ExprData.BinOp("NotEquals" /* NotEquals */, this[DATA], ExprData.create(that))
     );
   }
   isNull() {
-    return new _Expr(ExprData.UnOp("IsNull" /* IsNull */, this.expr));
+    return new Expr(ExprData.UnOp("IsNull" /* IsNull */, this[DATA]));
   }
   isNotNull() {
     return this.isNull().not();
   }
   isIn(that) {
-    return new _Expr(ExprData.BinOp("In" /* In */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("In" /* In */, this[DATA], ExprData.create(that))
+    );
   }
   isNotIn(that) {
-    return new _Expr(ExprData.BinOp("NotIn" /* NotIn */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("NotIn" /* NotIn */, this[DATA], ExprData.create(that))
+    );
   }
   isGreater(that) {
-    return new _Expr(ExprData.BinOp("Greater" /* Greater */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Greater" /* Greater */, this[DATA], ExprData.create(that))
+    );
   }
   isGreaterOrEqual(that) {
-    return new _Expr(
-      ExprData.BinOp("GreaterOrEqual" /* GreaterOrEqual */, this.expr, toExpr(that))
+    return new Expr(
+      ExprData.BinOp(
+        "GreaterOrEqual" /* GreaterOrEqual */,
+        this[DATA],
+        ExprData.create(that)
+      )
     );
   }
   isLess(that) {
-    return new _Expr(ExprData.BinOp("Less" /* Less */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Less" /* Less */, this[DATA], ExprData.create(that))
+    );
   }
   isLessOrEqual(that) {
-    return new _Expr(
-      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this.expr, toExpr(that))
+    return new Expr(
+      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this[DATA], ExprData.create(that))
     );
   }
   add(that) {
-    return new _Expr(ExprData.BinOp("Add" /* Add */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Add" /* Add */, this[DATA], ExprData.create(that))
+    );
   }
   substract(that) {
-    return new _Expr(ExprData.BinOp("Subt" /* Subt */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Subt" /* Subt */, this[DATA], ExprData.create(that))
+    );
   }
   multiply(that) {
-    return new _Expr(ExprData.BinOp("Mult" /* Mult */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Mult" /* Mult */, this[DATA], ExprData.create(that))
+    );
   }
   remainder(that) {
-    return new _Expr(ExprData.BinOp("Mod" /* Mod */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Mod" /* Mod */, this[DATA], ExprData.create(that))
+    );
   }
   divide(that) {
-    return new _Expr(ExprData.BinOp("Div" /* Div */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Div" /* Div */, this[DATA], ExprData.create(that))
+    );
   }
   concat(that) {
-    return new _Expr(ExprData.BinOp("Concat" /* Concat */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Concat" /* Concat */, this[DATA], ExprData.create(that))
+    );
   }
   like(that) {
-    return new _Expr(ExprData.BinOp("Like" /* Like */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Like" /* Like */, this[DATA], ExprData.create(that))
+    );
   }
   glob(that) {
-    return new _Expr(ExprData.BinOp("Glob" /* Glob */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Glob" /* Glob */, this[DATA], ExprData.create(that))
+    );
   }
   match(that) {
-    return new _Expr(ExprData.BinOp("Match" /* Match */, this.expr, toExpr(that)));
+    return new Expr(
+      ExprData.BinOp("Match" /* Match */, this[DATA], ExprData.create(that))
+    );
   }
   with(that) {
-    return new _Expr(
-      ExprData.Merge(this.expr, ExprData.create(that))
+    return new Expr(
+      ExprData.Merge(this[DATA], ExprData.create(that))
+    );
+  }
+  /**
+   * Dynamic expressions allow accessing runtime fields of JSON properties
+   * through a Proxy.
+   *
+   * Expr.value({a: {b: 1}}).dynamic().a.b.is(1) // true
+   **/
+  dynamic(...path) {
+    return new Proxy(
+      (...args) => {
+        const method = path.pop();
+        const e = path.length > 0 ? this.get(path.join(".")) : this;
+        return e[method]?.apply(e, args);
+      },
+      {
+        get: (_, key) => {
+          const e = path.length > 0 ? this.get(path.join(".")) : this;
+          if (key === "expr")
+            return e[DATA];
+          if (typeof key !== "string")
+            return e[key];
+          return this.dynamic(...path, key);
+        }
+      }
     );
   }
   at(index) {
     return this.get(`[${Number(index)}]`);
   }
   includes(value) {
-    return _Expr.create(value).isIn(this);
+    return Expr.create(value).isIn(this);
   }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
-    return new _Expr(
+    const target = Target.Expr(this[DATA], alias);
+    return new Expr(
       ExprData.Filter(
         target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
+        ExprData.create(fn(new Expr(ExprData.Row(target)).dynamic()))
       )
     );
   }
   map(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Expr(this.expr, alias);
-    return new _Expr(
+    const target = Target.Expr(this[DATA], alias);
+    return new Expr(
       ExprData.Map(
         target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
+        ExprData.create(fn(new Expr(ExprData.Row(target)).dynamic()))
       )
     );
   }
@@ -290,12 +320,37 @@ var _Expr = class extends callable {
     return this;
   }
   get(name) {
-    return new _Expr(ExprData.Field(this.expr, name));
+    return new Expr(ExprData.Field(this[DATA], name));
   }
 };
-var Expr = _Expr;
-__publicField(Expr, "NULL", _Expr.create(null));
-__publicField(Expr, "toExpr", Symbol("toExpr"));
+((Expr2) => {
+  Expr2.NULL = create(null);
+  Expr2.Data = DATA;
+  Expr2.IsExpr = IS_EXPR;
+  Expr2.ToExpr = TO_EXPR;
+  function value(value2) {
+    return new Expr2(ExprData.Param(ParamData.Value(value2)));
+  }
+  Expr2.value = value;
+  function create(input) {
+    if (isExpr(input))
+      return input;
+    return new Expr2(ExprData.create(input));
+  }
+  Expr2.create = create;
+  function and(...conditions) {
+    return conditions.map(create).reduce((condition, expr) => condition.and(expr), value(true));
+  }
+  Expr2.and = and;
+  function or(...conditions) {
+    return conditions.map(create).reduce((condition, expr) => condition.or(expr), value(false));
+  }
+  Expr2.or = or;
+  function isExpr(input) {
+    return input !== null && (typeof input === "object" || typeof input === "function") && input[IS_EXPR];
+  }
+  Expr2.isExpr = isExpr;
+})(Expr || (Expr = {}));
 export {
   BinOpType,
   Expr,

package/dist/define/Functions.js

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

package/dist/define/Ops.js

@@ -3,7 +3,7 @@ import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
-import { table as createTable } from "./Table.js";
+import { Table } from "./Table.js";
 import { Target } from "./Target.js";
 function select(selection) {
   return new Cursor.SelectMultiple(
@@ -13,7 +13,7 @@ function select(selection) {
   );
 }
 function from(source) {
-  const target = source instanceof Cursor ? Target.Query(source.query()) : Target.Table(source[createTable.data]);
+  const target = source instanceof Cursor ? Target.Query(source[Cursor.Query]) : Target.Table(source[Table.Data]);
   return new Cursor.SelectMultiple(
     Query.Select({
       from: target,
@@ -22,17 +22,17 @@ function from(source) {
   );
 }
 function update(table) {
-  return new Cursor.Update(Query.Update({ table: table[createTable.data] }));
+  return new Cursor.Update(Query.Update({ table: table[Table.Data] }));
 }
 function insertInto(table) {
-  return new Cursor.Insert(table[createTable.data]);
+  return new Cursor.Insert(table[Table.Data]);
 }
 function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table[createTable.data] }));
+  return new Cursor.Delete(Query.Delete({ table: table[Table.Data] }));
 }
 function create(...tables) {
   return new Cursor.Batch(
-    tables.flatMap((table) => Schema.create(table[createTable.data]).queries)
+    tables.flatMap((table) => Schema.create(table[Table.Data]).queries)
   );
 }
 export {

package/dist/define/Schema.js

@@ -33,7 +33,7 @@ var Schema;
             Object.fromEntries(
               Object.entries(table.columns).map(([key, column]) => [
                 key,
-                addedColumns.has(key) ? (typeof column.defaultValue === "function" ? column.defaultValue() : column.defaultValue) || Expr.NULL.expr : ExprData.Field(ExprData.Row(Target.Table(table)), key)
+                addedColumns.has(key) ? (typeof column.defaultValue === "function" ? column.defaultValue() : column.defaultValue) || Expr.NULL[Expr.Data] : ExprData.Field(ExprData.Row(Target.Table(table)), key)
               ])
             )
           )

package/dist/define/Selection.d.ts

@@ -5,12 +5,12 @@ interface SelectionRecord extends Record<string, Selection> {
 }
 export type Selection = SelectionBase | SelectionRecord;
 export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
+    const TableType: unique symbol;
+    const CursorType: unique symbol;
     type Infer<T> = T extends {
-        [__tableType](): infer K;
+        [TableType](): infer K;
     } ? K : T extends {
-        [__cursorType](): infer K;
+        [CursorType](): infer K;
     } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
         [K in keyof T]: Infer<T[K]>;
     } : T extends () => any ? never : unknown extends T ? never : T;

package/dist/define/Table.d.ts

@@ -3,6 +3,8 @@ import { Cursor } from './Cursor';
 import { EV } from './Expr';
 import { Index, IndexData } from './Index';
 import { Selection } from './Selection';
+declare const DATA: unique symbol;
+declare const META: unique symbol;
 interface TableDefinition {
 }
 export interface TableData {
@@ -21,8 +23,8 @@ export interface TableInstance<Definition> {
     (...conditions: Array<EV<boolean>>): Cursor.TableSelect<Definition>;
 }
 export declare class TableInstance<Definition> {
-    [Selection.__tableType](): Table.Select<Definition>;
-    get [table.data](): TableData;
+    [Selection.TableType](): Table.Select<Definition>;
+    get [DATA](): TableData;
     get name(): unknown;
     get length(): unknown;
     get call(): unknown;
@@ -32,6 +34,8 @@ export declare class TableInstance<Definition> {
 }
 export type Table<Definition> = Definition & TableInstance<Definition>;
 export declare namespace Table {
+    export const Data: typeof DATA;
+    export const Meta: typeof META;
     export type Of<Row> = Table<{
         [K in keyof Row as K extends string ? K : never]: Column<Row[K]>;
     }>;
@@ -52,18 +56,16 @@ export declare namespace Table {
 export interface TableMeta {
     indexes?: Record<string, Index>;
 }
-type Definition<T> = {
+type Blueprint<T> = {
     [K in keyof T as K extends string ? K : never]: Column<any> | (() => any);
 };
 interface Define<T> {
     new (): T;
 }
-type Blueprint<T> = Definition<T>;
 export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
 export declare function table<T extends Blueprint<T>>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {
-    const data: unique symbol;
-    const meta: unique symbol;
+    const meta: typeof META;
 }
 export {};