rado 0.4.1 → 0.4.3

package/README.md

@@ -222,7 +222,7 @@ const PostTags = table({
 ## Connections
 
 Currently supported SQLite drivers:
-`better-sqlite3`, `sql.js`, `sqlite3`, `bun:sqlite`
+`better-sqlite3`, `sql.js`, `sqlite3`, `bun:sqlite`, `@sqlite.org/sqlite-wasm`
 
 Pass an instance of the database to the `connect` function to get started:
 

package/dist/define/Expr.d.ts

@@ -112,6 +112,7 @@ export declare namespace ExprData {
         constructor(target: Target, condition: ExprData);
     }
     function create(input: any): ExprData;
+    function createAll(...inputs: Array<any>): Array<ExprData>;
 }
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
@@ -137,12 +138,12 @@ export declare class Expr<T> {
     isGreaterOrEqual(that: EV<any>): Expr<boolean>;
     isLess(that: EV<any>): Expr<boolean>;
     isLessOrEqual(that: EV<any>): Expr<boolean>;
-    add(this: Expr<number>, that: EV<number>): Expr<number>;
-    subtract(this: Expr<number>, that: EV<number>): Expr<number>;
-    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
+    add(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    subtract(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    multiply(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
     remainder(this: Expr<number>, that: EV<number>): Expr<number>;
-    divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    concat(this: Expr<string>, that: EV<string>): Expr<string>;
+    divide(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    concat(this: Expr<string>, that: EV<string>, ...rest: Array<EV<string>>): Expr<string>;
     like(this: Expr<string>, that: EV<string>): Expr<boolean>;
     glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
     match(this: Expr<string>, that: EV<string>): Expr<boolean>;

package/dist/define/Expr.js

@@ -147,6 +147,10 @@ var ExprData;
     return new ExprData2.Param(new ParamData.Value(input));
   }
   ExprData2.create = create;
+  function createAll(...inputs) {
+    return inputs.map(create);
+  }
+  ExprData2.createAll = createAll;
 })(ExprData || (ExprData = {}));
 class Expr {
   constructor(expr) {
@@ -273,19 +277,25 @@ class Expr {
       )
     );
   }
-  add(that) {
+  add(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Add" /* Add */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Add" /* Add */, a, b)
+      )
     );
   }
-  subtract(that) {
+  subtract(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Subt" /* Subt */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Subt" /* Subt */, a, b)
+      )
     );
   }
-  multiply(that) {
+  multiply(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Mult" /* Mult */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Mult" /* Mult */, a, b)
+      )
     );
   }
   remainder(that) {
@@ -293,17 +303,17 @@ class Expr {
       new ExprData.BinOp("Mod" /* Mod */, this[Expr.Data], ExprData.create(that))
     );
   }
-  divide(that) {
+  divide(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Div" /* Div */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Div" /* Div */, a, b)
+      )
     );
   }
-  concat(that) {
+  concat(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp(
-        "Concat" /* Concat */,
-        this[Expr.Data],
-        ExprData.create(that)
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Concat" /* Concat */, a, b)
       )
     );
   }

package/dist/define/Ops.js

@@ -26,10 +26,10 @@ const isGreater = (a, b) => Expr.create(a).isGreater(b);
 const isGreaterOrEqual = (a, b) => Expr.create(a).isGreaterOrEqual(b);
 const isLess = (a, b) => Expr.create(a).isLess(b);
 const isLessOrEqual = (a, b) => Expr.create(a).isLessOrEqual(b);
-const add = (a, b, ...rest) => [a, b].concat(rest).map(Expr.create).reduce((a2, b2) => a2.add(b2));
-const subtract = (a, b, ...rest) => [a, b].concat(rest).map(Expr.create).reduce((a2, b2) => a2.subtract(b2));
-const multiply = (a, b, ...rest) => [a, b].concat(rest).map(Expr.create).reduce((a2, b2) => a2.multiply(b2));
-const divide = (a, b, ...rest) => [a, b].concat(rest).map(Expr.create).reduce((a2, b2) => a2.divide(b2));
+const add = (a, b, ...rest) => Expr.create(a).add(b, ...rest);
+const subtract = (a, b, ...rest) => Expr.create(a).subtract(b, ...rest);
+const multiply = (a, b, ...rest) => Expr.create(a).multiply(b, ...rest);
+const divide = (a, b, ...rest) => Expr.create(a).divide(b, ...rest);
 const remainder = (a, b) => Expr.create(a).remainder(b);
 const concat = (a, b) => Expr.create(a).concat(b);
 const like = (a, b) => Expr.create(a).like(b);

package/dist/driver/@sqlite.org/sqlite-wasm.d.ts

@@ -0,0 +1,17 @@
+import { SchemaInstructions } from '../../define/Schema.js';
+import { Driver, DriverOptions } from '../../lib/Driver.js';
+import { Statement } from '../../lib/Statement.js';
+import { SqliteSchema } from '../../sqlite/SqliteSchema.js';
+type DatabaseApi = any;
+export declare class SqliteWasmDriver extends Driver.Sync {
+    db: DatabaseApi;
+    tableData?: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData?: (tableName: string) => Array<SqliteSchema.Index>;
+    constructor(db: DatabaseApi, options?: DriverOptions);
+    close(): void;
+    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: DatabaseApi, options?: DriverOptions): SqliteWasmDriver;
+export {};

package/dist/driver/@sqlite.org/sqlite-wasm.js

@@ -0,0 +1,80 @@
+import { Driver } from "../../lib/Driver.js";
+import { SqliteFormatter } from "../../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../../sqlite/SqliteSchema.js";
+class PreparedStatement {
+  constructor(db, stmt, discardAfter) {
+    this.db = db;
+    this.stmt = stmt;
+    this.discardAfter = discardAfter;
+  }
+  *iterate(params) {
+    if (params.length > 0)
+      this.stmt.bind(params);
+    while (this.stmt.step())
+      yield this.stmt.get({});
+    if (this.discardAfter)
+      this.stmt.finalize();
+    else
+      this.stmt.reset();
+  }
+  all(params) {
+    return Array.from(this.iterate(params));
+  }
+  run(params) {
+    if (params.length > 0)
+      this.stmt.bind(params);
+    this.stmt.step();
+    if (this.discardAfter)
+      this.stmt.finalize();
+    else
+      this.stmt.reset();
+    return { rowsAffected: this.db.changes() };
+  }
+  get(params) {
+    return this.all(params)[0];
+  }
+  execute(params) {
+    if (params.length > 0)
+      this.stmt.bind(params);
+    this.stmt.step();
+    if (this.discardAfter)
+      this.stmt.finalize();
+    else
+      this.stmt.reset();
+  }
+}
+class SqliteWasmDriver extends Driver.Sync {
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
+    this.db = db;
+  }
+  tableData;
+  indexData;
+  close() {
+    this.db.close();
+  }
+  prepareStatement(stmt, discardAfter) {
+    return new PreparedStatement(
+      this.db,
+      this.db.prepare(stmt.sql),
+      discardAfter
+    );
+  }
+  schemaInstructions(tableName) {
+    this.tableData = this.tableData || (this.tableData = this.prepare(SqliteSchema.tableData));
+    this.indexData = this.indexData || (this.indexData = this.prepare(SqliteSchema.indexData));
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  export() {
+    throw new Error("Not implemented");
+  }
+}
+function connect(db, options) {
+  return new SqliteWasmDriver(db, options);
+}
+export {
+  SqliteWasmDriver,
+  connect
+};

package/dist/driver/sql.js.js

@@ -13,6 +13,8 @@ class PreparedStatement {
       yield this.stmt.getAsObject();
     if (this.discardAfter)
       this.stmt.free();
+    else
+      this.stmt.reset();
   }
   all(params) {
     return Array.from(this.iterate(params));
@@ -21,6 +23,8 @@ class PreparedStatement {
     this.stmt.run(params);
     if (this.discardAfter)
       this.stmt.free();
+    else
+      this.stmt.reset();
     return { rowsAffected: this.db.getRowsModified() };
   }
   get(params) {
@@ -30,6 +34,8 @@ class PreparedStatement {
     this.stmt.run(params);
     if (this.discardAfter)
       this.stmt.free();
+    else
+      this.stmt.reset();
   }
 }
 class SqlJsDriver extends Driver.Sync {

package/dist/lib/Formatter.js

@@ -713,7 +713,7 @@ class Formatter {
             }
             stmt.identifier(field);
             if (asBoolean)
-              stmt.add(`, 'true', 'false'))`);
+              stmt.raw(`, 'true', 'false'))`);
             if (asJson)
               stmt.closeParenthesis();
             if (jsonColumn && !asJson)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,6 +48,7 @@
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20230628.0",
+    "@sqlite.org/sqlite-wasm": "^3.42.0-build4",
     "@types/better-sqlite3": "^5.4.1",
     "@types/glob": "^8.0.0",
     "@types/sql.js": "^1.4.2",