rado 0.2.13 → 0.2.14

package/dist/define/Column.d.ts

@@ -1,4 +1,3 @@
-import { Callable } from '../util/Callable';
 import { EV, Expr, ExprData } from './Expr';
 import { Fields } from './Fields';
 export declare enum ColumnType {
@@ -37,7 +36,7 @@ export declare namespace Column {
 interface ValueColumn<T> extends Expr<T> {
     <X extends T = T>(): ValueColumn<T extends null ? X | null : X>;
 }
-declare class ValueColumn<T> extends Callable implements Column<T> {
+declare class ValueColumn<T> implements Column<T> {
     [Column.type]: T;
     [Column.data]: PartialColumnData;
     constructor(data: PartialColumnData);
@@ -57,7 +56,7 @@ export declare class PrimaryColumn<T, K> extends ValueColumn<PrimaryKey<T, K>> {
 interface ObjectColumn<T> {
     <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<X>;
 }
-declare class ObjectColumn<T> extends Callable implements Column<T> {
+declare class ObjectColumn<T> implements Column<T> {
     [Column.type]: T;
     [Column.data]: PartialColumnData;
     constructor(data: PartialColumnData);
@@ -75,7 +74,7 @@ type DefaultValue<T> = EV<T> | (() => EV<T>);
 interface UnTyped {
     (name: string): UnTyped;
 }
-declare class UnTyped extends Callable {
+declare class UnTyped {
     [Column.data]: PartialColumnData;
     constructor(data?: PartialColumnData);
     get nullable(): NullableUnTyped;

package/dist/define/Column.js

@@ -1,5 +1,5 @@
 // src/define/Column.ts
-import { Callable } from "../util/Callable.js";
+import { callable } from "../util/Callable.js";
 import { Expr, ExprData } from "./Expr.js";
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
@@ -14,17 +14,17 @@ var Column;
   Column2.data = Symbol("columnData");
   Column2.type = Symbol("columnType");
 })(Column || (Column = {}));
-var ValueColumn = class extends Callable {
+var ValueColumn = class {
   [Column.type];
   [Column.data];
   constructor(data) {
-    super((defaultValue) => {
+    this[Column.data] = data;
+    return callable(this, (defaultValue) => {
       return new ValueColumn({
         ...this[Column.data],
         defaultValue: createDefaultValue(defaultValue)
       });
     });
-    this[Column.data] = data;
   }
   get nullable() {
     return new ValueColumn({ ...this[Column.data], nullable: true });
@@ -46,7 +46,7 @@ var ValueColumn = class extends Callable {
     return new ValueColumn({
       ...this[Column.data],
       references() {
-        return ExprData.create(column2 instanceof Expr ? column2 : column2());
+        return ExprData.create(Expr.isExpr(column2) ? column2 : column2());
       }
     });
   }
@@ -58,7 +58,7 @@ var ValueColumn = class extends Callable {
   }
 };
 function createDefaultValue(value) {
-  return typeof value === "function" && !(value instanceof Expr) ? () => ExprData.create(value()) : ExprData.create(value);
+  return typeof value === "function" && !Expr.isExpr(value) ? () => ExprData.create(value()) : ExprData.create(value);
 }
 var OptionalColumn = class extends ValueColumn {
   [Column.isOptional];
@@ -66,12 +66,12 @@ var OptionalColumn = class extends ValueColumn {
 var PrimaryColumn = class extends ValueColumn {
   [Column.isPrimary];
 };
-var ObjectColumn = class extends Callable {
+var ObjectColumn = class {
   [Column.type];
   [Column.data];
   constructor(data) {
-    super(() => this);
     this[Column.data] = data;
+    return callable(this, () => this);
   }
   get nullable() {
     return new ObjectColumn({ ...this[Column.data], nullable: true });
@@ -89,13 +89,13 @@ var ObjectColumn = class extends Callable {
 var OptionalObjectColumn = class extends ObjectColumn {
   [Column.isOptional];
 };
-var UnTyped = class extends Callable {
+var UnTyped = class {
   [Column.data];
   constructor(data = {}) {
-    super((name) => {
+    this[Column.data] = data;
+    return callable(this, (name) => {
       return new ValueColumn({ ...data, name });
     });
-    this[Column.data] = data;
   }
   get nullable() {
     return new UnTyped({ ...this[Column.data], nullable: true });

package/dist/define/Cursor.js

@@ -187,7 +187,7 @@ function addWhere(query, where) {
       return new SelectMultiple({
         ...this.query(),
         orderBy: orderBy.map((e) => {
-          return e instanceof Expr ? e.asc() : e;
+          return Expr.isExpr(e) ? e.asc() : e;
         })
       });
     }

package/dist/define/Expr.d.ts

@@ -126,10 +126,8 @@ export declare const ExprData: {
 };
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
-declare class Empty {
-}
-declare const callable: typeof Empty;
-export declare class Expr<T> extends callable {
+declare const isExpr: unique symbol;
+export declare class Expr<T> {
     expr: ExprData;
     static NULL: Expr<null>;
     static toExpr: symbol;
@@ -137,7 +135,9 @@ export declare class Expr<T> extends callable {
     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;
     asc(): OrderBy;
     desc(): OrderBy;
     not(): Expr<boolean>;

package/dist/define/Expr.js

@@ -94,7 +94,7 @@ var ExprData = {
       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)
+    if (Expr.isExpr(input))
       return input.expr;
     if (input && typeof input === "object" && !Array.isArray(input))
       return ExprData.Record(
@@ -123,27 +123,28 @@ 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);
+  return new Proxy(
+    (...args) => {
       const method = path.pop();
+      const proto = Expr.prototype;
       const e = path.length > 0 ? dotAccess(expr, path) : expr;
-      return proto[method].apply(e, args);
+      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);
+    {
+      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 {
+var isExpr = Symbol("isExpr");
+var _Expr = class {
   constructor(expr) {
-    super();
     this.expr = expr;
     return exprAccess(this);
   }
@@ -151,7 +152,7 @@ var _Expr = class extends callable {
     return new _Expr(ExprData.Param(ParamData.Value(value)));
   }
   static create(input) {
-    if (input instanceof _Expr)
+    if (_Expr.isExpr(input))
       return input;
     return new _Expr(ExprData.create(input));
   }
@@ -161,6 +162,10 @@ var _Expr = class extends callable {
   static or(...conditions) {
     return conditions.map(_Expr.create).reduce((condition, expr) => condition.or(expr), _Expr.value(false));
   }
+  static isExpr(input) {
+    return input !== null && (typeof input === "object" || typeof input === "function") && input[isExpr];
+  }
+  [isExpr] = true;
   asc() {
     return { expr: this.expr, order: OrderDirection.Asc };
   }
@@ -189,12 +194,12 @@ var _Expr = class extends callable {
     return new _Expr(ExprData.BinOp("And" /* And */, a, b));
   }
   is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+    if (that === null || _Expr.isExpr(that) && 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))
+    if (that === null || _Expr.isExpr(that) && isConstant(that.expr, null))
       return this.isNotNull();
     return new _Expr(
       ExprData.BinOp("NotEquals" /* NotEquals */, this.expr, toExpr(that))

package/dist/define/Table.js

@@ -28,7 +28,7 @@ function createTable(data) {
   const target = Target.Table(data);
   const call = {
     [data.name]: function(...args) {
-      const isConditionalRecord = args.length === 1 && typeof args[0] === "object" && !(args[0] instanceof Expr);
+      const isConditionalRecord = args.length === 1 && !Expr.isExpr(args[0]);
       const conditions = isConditionalRecord ? entries(args[0]).map(([key, value]) => {
         const column = data.columns[key];
         if (!column)

package/dist/lib/Driver.d.ts

@@ -3,10 +3,9 @@ import { Expr } from '../define/Expr';
 import { Query } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Table } from '../define/Table';
-import { Callable } from '../util/Callable';
 import { Formatter } from './Formatter';
 import { Statement } from './Statement';
-declare abstract class DriverBase extends Callable {
+declare abstract class DriverBase {
     formatter: Formatter;
     constructor(formatter: Formatter);
     compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];

package/dist/lib/Driver.js

@@ -5,13 +5,14 @@ import { ParamData } from "../define/Param.js";
 import { Query, QueryType } from "../define/Query.js";
 import { Schema } from "../define/Schema.js";
 import { table } from "../define/Table.js";
-import { Callable } from "../util/Callable.js";
+import { callable } from "../util/Callable.js";
 function isTemplateStringsArray(input) {
   return Boolean(Array.isArray(input) && input.raw);
 }
-var DriverBase = class extends Callable {
+var DriverBase = class {
   constructor(formatter) {
-    super((...args) => {
+    this.formatter = formatter;
+    return callable(this, (...args) => {
       const [input, ...rest] = args;
       if (input instanceof Cursor && rest.length === 0)
         return this.executeQuery(input.query());
@@ -23,7 +24,6 @@ var DriverBase = class extends Callable {
         })
       );
     });
-    this.formatter = formatter;
   }
   compile(create) {
     const { length } = create;

package/dist/lib/Formatter.js

@@ -134,7 +134,7 @@ var Formatter = class {
     for (const key of stmt.separate(keys)) {
       stmt.identifier(key).add("=").space();
       const value = data[key];
-      if (value instanceof Expr)
+      if (Expr.isExpr(value))
         this.formatExprJson(ctx, ExprData.create(data[key]));
       else
         this.formatValue({ ...ctx, formatAsInsert: true }, value);
@@ -245,7 +245,7 @@ var Formatter = class {
       ctx.stmt.raw(strings[i]);
       if (i < params.length) {
         const param = params[i];
-        if (param instanceof Expr)
+        if (Expr.isExpr(param))
           this.formatExpr(ctx, param.expr);
         else
           this.formatValue(ctx, param);
@@ -316,7 +316,7 @@ var Formatter = class {
   }
   formatColumnValue(ctx, column, columnValue) {
     const { stmt } = ctx;
-    if (columnValue instanceof Expr)
+    if (Expr.isExpr(columnValue))
       return this.formatExprValue(ctx, columnValue.expr);
     const isNull = columnValue === void 0 || columnValue === null;
     const isOptional = column.nullable || column.autoIncrement || column.primaryKey;

package/dist/util/Callable.d.ts

@@ -1,3 +1 @@
-export declare class Callable extends Function {
-    constructor(fn: Function);
-}
+export declare function callable(target: any, call: Function): any;

package/dist/util/Callable.js

@@ -1,14 +1,15 @@
 // src/util/Callable.ts
-var Callable = class extends Function {
-  constructor(fn) {
-    super();
-    return new Proxy(this, {
-      apply(_, thisArg, input) {
-        return fn.apply(thisArg, input);
-      }
-    });
-  }
-};
+function callable(target, call) {
+  return new Proxy(call, {
+    set(_, prop, value) {
+      target[prop] = value;
+      return true;
+    },
+    get(_, prop) {
+      return target[prop];
+    }
+  });
+}
 export {
-  Callable
+  callable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",