rado 0.2.13 → 0.2.15

package/dist/define/Table.js

@@ -1,8 +1,13 @@
 // src/define/Table.ts
-import { Column } from "./Column.js";
+import {
+  Column,
+  ColumnType
+} from "./Column.js";
 import { Cursor } from "./Cursor.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
 import { Target } from "./Target.js";
+var DATA = Symbol("Table.Data");
+var META = Symbol("Table.Meta");
 var {
   keys,
   entries,
@@ -14,6 +19,11 @@ var {
   getOwnPropertyDescriptor
 } = Object;
 var { ownKeys } = Reflect;
+var Table;
+((Table2) => {
+  Table2.Data = DATA;
+  Table2.Meta = META;
+})(Table || (Table = {}));
 function keysOf(input) {
   const methods = [];
   while (input = getPrototypeOf(input)) {
@@ -28,7 +38,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)
@@ -46,17 +56,20 @@ function createTable(data) {
   }[data.name];
   const cols = keys(data.columns);
   const hasKeywords = cols.concat(keysOf(data.definition)).some((name) => name in Function);
+  const row = ExprData.Row(target);
   const expressions = fromEntries(
-    cols.map((name) => [
-      name,
-      new Expr(ExprData.Field(ExprData.Row(target), name))
-    ])
+    cols.map((name) => {
+      let expr = new Expr(ExprData.Field(row, name));
+      if (data.columns[name].type === ColumnType.Json)
+        expr = expr.dynamic();
+      return [name, expr];
+    })
   );
-  const toExpr = () => new Expr(ExprData.Row(target));
+  const toExpr = () => new Expr(row);
   const ownKeys2 = ["prototype", ...cols];
   let res;
   if (!hasKeywords) {
-    res = assign(call, expressions, { [table.data]: data, [Expr.toExpr]: toExpr });
+    res = assign(call, expressions, { [DATA]: data, [Expr.ToExpr]: toExpr });
     setPrototypeOf(call, getPrototypeOf(data.definition));
   } else {
     let get2 = function(key) {
@@ -65,9 +78,9 @@ function createTable(data) {
     var get = get2;
     res = new Proxy(call, {
       get(target2, key) {
-        if (key === table.data)
+        if (key === DATA)
           return data;
-        if (key === Expr.toExpr)
+        if (key === Expr.ToExpr)
           return toExpr;
         return get2(key);
       },
@@ -101,7 +114,7 @@ function table(define) {
     columns: fromEntries(
       entries(getOwnPropertyDescriptors(columns)).map(([name2, descriptor]) => {
         const column = columns[name2];
-        const data = column[Column.data];
+        const data = column[Column.Data];
         if (!data.type)
           throw new Error(`Column ${name2} has no type`);
         return [
@@ -131,10 +144,10 @@ function table(define) {
   return res;
 }
 ((table2) => {
-  table2.data = Symbol("data");
-  table2.meta = Symbol("meta");
+  table2.meta = META;
 })(table || (table = {}));
 export {
+  Table,
   createTable,
   table
 };

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

@@ -4,26 +4,26 @@ import { Expr, ExprData } from "../define/Expr.js";
 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 { Table } from "../define/Table.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());
+        return this.executeQuery(input[Cursor.Query]);
       if (isTemplateStringsArray(input))
         return this.executeTemplate(void 0, input, ...rest);
       return this.executeQuery(
         Query.Batch({
-          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg.query())
+          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg[Cursor.Query])
         })
       );
     });
-    this.formatter = formatter;
   }
   compile(create) {
     const { length } = create;
@@ -32,23 +32,23 @@ var DriverBase = class extends Callable {
       (name) => new Expr(ExprData.Param(ParamData.Named(name)))
     );
     const cursor = create(...params);
-    const query = cursor.query();
+    const query = cursor[Cursor.Query];
     return [query, this.formatter.compile(query)];
   }
   all(...args) {
     const [input, ...rest] = args;
     if (input instanceof Cursor.SelectSingle)
-      return this.executeQuery(input.all().query());
+      return this.executeQuery(input.all()[Cursor.Query]);
     if (input instanceof Cursor)
-      return this.executeQuery(input.query());
+      return this.executeQuery(input[Cursor.Query]);
     return this.executeTemplate("rows", input, ...rest);
   }
   get(...args) {
     const [input, ...rest] = args;
     if (input instanceof Cursor.SelectMultiple)
-      return this.executeQuery(input.first().query());
+      return this.executeQuery(input.first()[Cursor.Query]);
     if (input instanceof Cursor)
-      return this.executeQuery(input.query());
+      return this.executeQuery(input[Cursor.Query]);
     return this.executeTemplate("row", input, ...rest);
   }
   sql(strings, ...params) {
@@ -73,7 +73,7 @@ var SyncDriver = class extends DriverBase {
   migrateSchema(...tables) {
     const queries = [];
     for (const current of Object.values(tables)) {
-      const schema = current[table.data];
+      const schema = current[Table.Data];
       const localSchema = this.schemaInstructions(schema.name);
       if (!localSchema) {
         queries.push(...Schema.create(schema).queries);
@@ -135,7 +135,7 @@ var SyncDriver = class extends DriverBase {
   }
   *iterate(cursor) {
     const stmt = this.prepareStatement(
-      this.formatter.compile(cursor.query()),
+      this.formatter.compile(cursor[Cursor.Query]),
       true
     );
     for (const row of stmt.iterate()) {
@@ -179,7 +179,7 @@ var AsyncDriver = class extends DriverBase {
   async migrateSchema(...tables) {
     const queries = [];
     for (const current of Object.values(tables)) {
-      const schema = current[table.data];
+      const schema = current[Table.Data];
       const localSchema = await this.schemaInstructions(schema.name);
       if (!localSchema) {
         queries.push(...Schema.create(schema).queries);
@@ -243,7 +243,7 @@ var AsyncDriver = class extends DriverBase {
   }
   async *iterate(cursor) {
     const stmt = this.prepareStatement(
-      this.formatter.compile(cursor.query()),
+      this.formatter.compile(cursor[Cursor.Query]),
       true
     );
     for await (const row of stmt.iterate()) {

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,8 +245,8 @@ var Formatter = class {
       ctx.stmt.raw(strings[i]);
       if (i < params.length) {
         const param = params[i];
-        if (param instanceof Expr)
-          this.formatExpr(ctx, param.expr);
+        if (Expr.isExpr(param))
+          this.formatExpr(ctx, param[Expr.Data]);
         else
           this.formatValue(ctx, param);
       }
@@ -316,8 +316,8 @@ var Formatter = class {
   }
   formatColumnValue(ctx, column, columnValue) {
     const { stmt } = ctx;
-    if (columnValue instanceof Expr)
-      return this.formatExprValue(ctx, columnValue.expr);
+    if (Expr.isExpr(columnValue))
+      return this.formatExprValue(ctx, columnValue[Expr.Data]);
     const isNull = columnValue === void 0 || columnValue === null;
     const isOptional = column.nullable || column.autoIncrement || column.primaryKey;
     if (isNull) {

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.15",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,7 +46,7 @@
     "speedscope": "^1.15.0",
     "sql.js": "^1.8.0",
     "sqlite3": "^5.1.4",
-    "tsx": "^3.12.1",
+    "tsx": "^3.12.3",
     "typescript": "next",
     "uvu": "^0.5.6"
   },