rado 0.3.9 → 0.4.0

package/dist/define/Expr.d.ts

@@ -138,7 +138,7 @@ export declare class Expr<T> {
     isLess(that: EV<any>): Expr<boolean>;
     isLessOrEqual(that: EV<any>): Expr<boolean>;
     add(this: Expr<number>, that: EV<number>): Expr<number>;
-    substract(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>;
     remainder(this: Expr<number>, that: EV<number>): Expr<number>;
     divide(this: Expr<number>, that: EV<number>): Expr<number>;

package/dist/define/Expr.js

@@ -278,7 +278,7 @@ class Expr {
       new ExprData.BinOp("Add" /* Add */, this[Expr.Data], ExprData.create(that))
     );
   }
-  substract(that) {
+  subtract(that) {
     return new Expr(
       new ExprData.BinOp("Subt" /* Subt */, this[Expr.Data], ExprData.create(that))
     );
@@ -402,6 +402,8 @@ class Expr {
   Expr2.ToExpr = Symbol("Expr.ToExpr");
   Expr2.NULL = create(null);
   function value(value2, inline = false) {
+    if (isExpr(value2))
+      return value2;
     return new Expr2(new ExprData.Param(new ParamData.Value(value2, inline)));
   }
   Expr2.value = value;

package/dist/define/Ops.d.ts

@@ -1,6 +1,31 @@
+import { EV, Expr } from './Expr.js';
 import { Batch, Delete, InsertInto, RecursiveUnion, Select, Update } from './Query.js';
 import { Selection } from './Selection.js';
 import { Table } from './Table.js';
+export declare const value: typeof Expr.value;
+export declare const and: typeof Expr.and;
+export declare const or: typeof Expr.or;
+export declare const not: <T>(a: EV<T>) => Expr<boolean>;
+export declare const is: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const isNot: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const isNull: <T>(a: EV<T>) => Expr<boolean>;
+export declare const isNotNull: <T>(a: EV<T>) => Expr<boolean>;
+export declare const isIn: <T>(a: EV<T>, b: EV<T[]> | Select<T>) => Expr<boolean>;
+export declare const isNotIn: <T>(a: EV<T>, b: EV<T[]> | Select<T>) => Expr<boolean>;
+export declare const isGreater: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const isGreaterOrEqual: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const isLess: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const isLessOrEqual: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const add: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
+export declare const subtract: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
+export declare const multiply: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
+export declare const divide: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
+export declare const remainder: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
+export declare const concat: <T extends string>(a: EV<T>, b: EV<T>) => Expr<string>;
+export declare const like: <T extends string>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const glob: <T extends string>(a: EV<T>, b: EV<T>) => Expr<boolean>;
+export declare const at: <T extends string>(a: EV<T[]>, index: number) => Expr<T | null>;
+export declare const includes: <T extends string>(a: EV<T[]>, value: EV<T>) => Expr<boolean>;
 export declare function withRecursive<Row>(initialSelect: Select<Row>): RecursiveUnion<Row>;
 export declare function alias<T extends Table<{}>>(table: T): Record<string, T>;
 export declare function select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;

package/dist/define/Ops.js

@@ -1,4 +1,4 @@
-import { ExprData } from "./Expr.js";
+import { Expr, ExprData } from "./Expr.js";
 import {
   Batch,
   Delete,
@@ -12,6 +12,30 @@ import {
 import { Schema } from "./Schema.js";
 import { Table, createTable } from "./Table.js";
 import { Target } from "./Target.js";
+const value = Expr.value;
+const and = Expr.and;
+const or = Expr.or;
+const not = (a) => Expr.create(a).not();
+const is = (a, b) => Expr.create(a).is(b);
+const isNot = (a, b) => Expr.create(a).isNot(b);
+const isNull = (a) => Expr.create(a).isNull();
+const isNotNull = (a) => Expr.create(a).isNotNull();
+const isIn = (a, b) => Expr.create(a).isIn(b);
+const isNotIn = (a, b) => Expr.create(a).isNotIn(b);
+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) => Expr.create(a).add(b);
+const subtract = (a, b) => Expr.create(a).subtract(b);
+const multiply = (a, b) => Expr.create(a).multiply(b);
+const divide = (a, b) => Expr.create(a).divide(b);
+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);
+const glob = (a, b) => Expr.create(a).glob(b);
+const at = (a, index) => Expr.create(a).at(index);
+const includes = (a, value2) => Expr.create(a).includes(value2);
 function withRecursive(initialSelect) {
   return new RecursiveUnion(initialSelect[Query.Data]);
 }
@@ -55,12 +79,36 @@ function create(...tables) {
   );
 }
 export {
+  add,
   alias,
+  and,
+  at,
+  concat,
   create,
   deleteFrom,
+  divide,
   from,
+  glob,
+  includes,
   insertInto,
+  is,
+  isGreater,
+  isGreaterOrEqual,
+  isIn,
+  isLess,
+  isLessOrEqual,
+  isNot,
+  isNotIn,
+  isNotNull,
+  isNull,
+  like,
+  multiply,
+  not,
+  or,
+  remainder,
   select,
+  subtract,
   update,
+  value,
   withRecursive
 };

package/dist/driver/better-sqlite3.js

@@ -5,19 +5,19 @@ class PreparedStatement {
   constructor(stmt) {
     this.stmt = stmt;
   }
-  iterate(params = []) {
+  iterate(params) {
     return this.stmt.iterate(...params);
   }
-  all(params = []) {
+  all(params) {
     return this.stmt.all(...params);
   }
-  run(params = []) {
+  run(params) {
     return { rowsAffected: this.stmt.run(...params).changes };
   }
-  get(params = []) {
+  get(params) {
     return this.stmt.get(...params);
   }
-  execute(params = []) {
+  execute(params) {
     this.stmt.run(...params);
   }
 }

package/dist/driver/bun-sqlite.js

@@ -7,21 +7,21 @@ class PreparedStatement {
     this.lastChanges = lastChanges;
     this.stmt = stmt;
   }
-  *iterate(params = []) {
+  *iterate(params) {
     for (const row of this.stmt.all(...params))
       yield row;
   }
-  all(params = []) {
+  all(params) {
     return this.stmt.all(...params);
   }
-  run(params = []) {
+  run(params) {
     this.stmt.run(...params);
     return this.lastChanges();
   }
-  get(params = []) {
+  get(params) {
     return this.stmt.get(...params);
   }
-  execute(params = []) {
+  execute(params) {
     this.stmt.run(...params);
   }
 }

package/dist/driver/d1.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="@cloudflare/workers-types" />
+import { QueryData } from '../define/Query.js';
+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';
+export declare class D1Driver extends Driver.Async {
+    private db;
+    lock: Promise<void> | undefined;
+    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
+    indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
+    constructor(db: D1Database, options?: DriverOptions);
+    executeQuery(query: QueryData, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<unknown>;
+    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+    close(): Promise<void>;
+}
+export declare function connect(db: D1Database, options?: DriverOptions): D1Driver;

package/dist/driver/d1.js

@@ -0,0 +1,69 @@
+import { Driver } from "../lib/Driver.js";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+class PreparedStatement {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  async *iterate(params) {
+    yield* await this.all(params);
+  }
+  async all(params) {
+    return this.stmt.bind(...params).raw();
+  }
+  async run(params) {
+    const results = await this.stmt.bind(...params).raw();
+    return {
+      get rowsAffected() {
+        throw new Error(`Affected rows cannot be queried on D1`);
+      }
+    };
+  }
+  async get(params) {
+    return (await this.all(params))[0];
+  }
+  async execute(params) {
+    this.stmt.bind(...params).raw();
+  }
+}
+class D1Driver extends Driver.Async {
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+  }
+  lock;
+  tableData;
+  indexData;
+  async executeQuery(query, stmt, params) {
+    await this.lock;
+    return super.executeQuery(query, stmt, params);
+  }
+  prepareStatement(stmt) {
+    return new PreparedStatement(this.db.prepare(stmt.sql));
+  }
+  async schemaInstructions(tableName) {
+    const columnData = await this.tableData(tableName);
+    const indexData = await this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  isolate() {
+    const connection = new D1Driver(this.db);
+    let release, trigger = new Promise((resolve) => {
+      release = async () => resolve();
+    });
+    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    return [connection, release];
+  }
+  async close() {
+    await this.lock;
+  }
+}
+function connect(db, options) {
+  return new D1Driver(db, options);
+}
+export {
+  D1Driver,
+  connect
+};

package/dist/lib/Driver.d.ts

@@ -81,13 +81,13 @@ declare class SyncWrapper extends AsyncDriver {
     isolate(): [connection: AsyncDriver, release: () => Promise<void>];
 }
 interface AsyncPreparedStatement {
-    run(params?: Array<any>): Promise<{
+    run(params: Array<any>): Promise<{
         rowsAffected: number;
     }>;
-    iterate<T>(params?: Array<any>): AsyncIterable<T>;
-    all<T>(params?: Array<any>): Promise<Array<T>>;
-    get<T>(params?: Array<any>): Promise<T>;
-    execute(params?: Array<any>): Promise<void>;
+    iterate<T>(params: Array<any>): AsyncIterable<T>;
+    all<T>(params: Array<any>): Promise<Array<T>>;
+    get<T>(params: Array<any>): Promise<T>;
+    execute(params: Array<any>): Promise<void>;
 }
 export type Driver = SyncDriver | AsyncDriver;
 export declare namespace Driver {

package/dist/lib/Driver.js

@@ -302,7 +302,7 @@ class AsyncDriver extends DriverBase {
       this.formatter.compile(cursor[Query.Data]),
       true
     );
-    for await (const row of stmt.iterate()) {
+    for await (const row of stmt.iterate([])) {
       yield JSON.parse(row.result).result;
     }
   }

package/dist/sqlite/SqliteFunctions.d.ts

@@ -134,7 +134,7 @@ export type SqliteFunctions = {
     /** Return the remainder after dividing X by Y. This is similar to the '%' operator, except that it works for non-numbereger arguments. */
     mod(x: EV<number>, y: EV<number>): Expr<number>;
     /** Return an approximation for π. */
-    pi(x: EV<number>): Expr<number>;
+    pi(): Expr<number>;
     /** Compute X raised to the power Y. */
     pow(x: EV<number>, y: EV<number>): Expr<number>;
     /** Convert X from degrees numbero radians. */
@@ -162,4 +162,4 @@ export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<bool
     (x: EV<any>, type: 'real'): Expr<number>;
     (x: EV<any>, type: 'integer'): Expr<number>;
     (x: EV<any>, type: 'numeric'): Expr<number>;
-}, abs: (x: EV<number>) => Expr<number>, changes: () => Expr<number>, char: (...arg: Array<EV<number>>) => Expr<string>, coalesce: (x: EV<any>, y: EV<any>, ...rest: EV<any>) => Expr<any>, ifnull: <T>(x: EV<T>, y: EV<T>) => Expr<T>, instr: (x: EV<string>, y: EV<string>) => Expr<number>, last_insert_rowid: () => Expr<number>, length: (x: EV<string>) => Expr<number>, likelihood: (x: EV<boolean>, y: number) => Expr<boolean>, likely: (x: EV<boolean>) => Expr<boolean>, lower: (x: EV<string>) => Expr<string>, ltrim: (x: EV<string>, y?: EV<string>) => Expr<string>, max: <T>(x: EV<T>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: EV<T>, ...rest: EV<T>[]) => Expr<T>, nullif: <T>(x: EV<T>, y: EV<T>) => Expr<T | null>, prnumberf: (format: string, ...rest: Array<Expr<any>>) => Expr<string>, quote: (x: EV<string>) => Expr<string>, random: () => Expr<number>, replace: (x: EV<string>, y: EV<string>, z: EV<string>) => Expr<string>, round: (x: EV<number>, y?: EV<number>) => Expr<number>, rtrim: (x: EV<string>, y?: EV<string>) => Expr<string>, sign: (x: EV<number>) => Expr<number>, soundex: (x: EV<string>) => Expr<string>, sqlite_version: () => Expr<string>, substr: (x: EV<string>, y: EV<number>, z?: EV<number>) => Expr<string>, total_changes: () => Expr<number>, trim: (x: EV<string>, Y: EV<string>) => Expr<string>, unicode: (x: EV<string>) => Expr<number>, unlikely: (x: EV<boolean>) => Expr<boolean>, upper: (x: EV<string>) => Expr<string>, avg: (x: Expr<number>) => Expr<number>, group_concat: (x: EV<string>, y?: EV<string>) => Expr<string>, sum: (x: EV<number>) => Expr<number>, acos: (x: EV<number>) => Expr<number>, acosh: (x: EV<number>) => Expr<number>, asin: (x: EV<number>) => Expr<number>, asinh: (x: EV<number>) => Expr<number>, atan: (x: EV<number>) => Expr<number>, atan2: (x: EV<number>, y: EV<number>) => Expr<number>, atanh: (x: EV<number>) => Expr<number>, ceil: (x: EV<number>) => Expr<number>, cos: (x: EV<number>) => Expr<number>, cosh: (x: EV<number>) => Expr<number>, degrees: (x: EV<number>) => Expr<number>, exp: (x: EV<number>) => Expr<number>, floor: (x: EV<number>) => Expr<number>, ln: (x: EV<number>) => Expr<number>, log: (x: EV<number>, y?: EV<number>) => Expr<number>, log2: (x: EV<number>) => Expr<number>, mod: (x: EV<number>, y: EV<number>) => Expr<number>, pi: (x: EV<number>) => Expr<number>, pow: (x: EV<number>, y: EV<number>) => Expr<number>, radians: (x: EV<number>) => Expr<number>, sin: (x: EV<number>) => Expr<number>, sinh: (x: EV<number>) => Expr<number>, sqrt: (x: EV<number>) => Expr<number>, tan: (x: EV<number>) => Expr<number>, tanh: (x: EV<number>) => Expr<number>, trunc: (x: EV<number>) => Expr<number>, date: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, time: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, datetime: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, julianday: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, strftime: (format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>;
+}, abs: (x: EV<number>) => Expr<number>, changes: () => Expr<number>, char: (...arg: Array<EV<number>>) => Expr<string>, coalesce: (x: EV<any>, y: EV<any>, ...rest: EV<any>) => Expr<any>, ifnull: <T>(x: EV<T>, y: EV<T>) => Expr<T>, instr: (x: EV<string>, y: EV<string>) => Expr<number>, last_insert_rowid: () => Expr<number>, length: (x: EV<string>) => Expr<number>, likelihood: (x: EV<boolean>, y: number) => Expr<boolean>, likely: (x: EV<boolean>) => Expr<boolean>, lower: (x: EV<string>) => Expr<string>, ltrim: (x: EV<string>, y?: EV<string>) => Expr<string>, max: <T>(x: EV<T>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: EV<T>, ...rest: EV<T>[]) => Expr<T>, nullif: <T>(x: EV<T>, y: EV<T>) => Expr<T | null>, prnumberf: (format: string, ...rest: Array<Expr<any>>) => Expr<string>, quote: (x: EV<string>) => Expr<string>, random: () => Expr<number>, replace: (x: EV<string>, y: EV<string>, z: EV<string>) => Expr<string>, round: (x: EV<number>, y?: EV<number>) => Expr<number>, rtrim: (x: EV<string>, y?: EV<string>) => Expr<string>, sign: (x: EV<number>) => Expr<number>, soundex: (x: EV<string>) => Expr<string>, sqlite_version: () => Expr<string>, substr: (x: EV<string>, y: EV<number>, z?: EV<number>) => Expr<string>, total_changes: () => Expr<number>, trim: (x: EV<string>, Y: EV<string>) => Expr<string>, unicode: (x: EV<string>) => Expr<number>, unlikely: (x: EV<boolean>) => Expr<boolean>, upper: (x: EV<string>) => Expr<string>, avg: (x: Expr<number>) => Expr<number>, group_concat: (x: EV<string>, y?: EV<string>) => Expr<string>, sum: (x: EV<number>) => Expr<number>, acos: (x: EV<number>) => Expr<number>, acosh: (x: EV<number>) => Expr<number>, asin: (x: EV<number>) => Expr<number>, asinh: (x: EV<number>) => Expr<number>, atan: (x: EV<number>) => Expr<number>, atan2: (x: EV<number>, y: EV<number>) => Expr<number>, atanh: (x: EV<number>) => Expr<number>, ceil: (x: EV<number>) => Expr<number>, cos: (x: EV<number>) => Expr<number>, cosh: (x: EV<number>) => Expr<number>, degrees: (x: EV<number>) => Expr<number>, exp: (x: EV<number>) => Expr<number>, floor: (x: EV<number>) => Expr<number>, ln: (x: EV<number>) => Expr<number>, log: (x: EV<number>, y?: EV<number>) => Expr<number>, log2: (x: EV<number>) => Expr<number>, mod: (x: EV<number>, y: EV<number>) => Expr<number>, pi: () => Expr<number>, pow: (x: EV<number>, y: EV<number>) => Expr<number>, radians: (x: EV<number>) => Expr<number>, sin: (x: EV<number>) => Expr<number>, sinh: (x: EV<number>) => Expr<number>, sqrt: (x: EV<number>) => Expr<number>, tan: (x: EV<number>) => Expr<number>, tanh: (x: EV<number>) => Expr<number>, trunc: (x: EV<number>) => Expr<number>, date: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, time: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, datetime: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, julianday: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, strftime: (format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.3.9",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,13 +47,14 @@
     "prepublishOnly": "tsc -p tsconfig.build.json && tsx build.ts"
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^4.20230628.0",
     "@types/better-sqlite3": "^5.4.1",
     "@types/glob": "^8.0.0",
     "@types/sql.js": "^1.4.2",
     "better-sqlite3": "^7.5.1",
     "bun-types": "^0.5.0",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.17.10",
+    "esbuild": "^0.18.11",
     "glob": "^8.0.3",
     "rimraf": "^4.1.2",
     "sade": "^1.8.1",
@@ -67,8 +68,5 @@
   "volta": {
     "node": "18.12.1"
   },
-  "packageManager": "yarn@3.3.1",
-  "resolutions": {
-    "esbuild": "0.17.10"
-  }
+  "packageManager": "yarn@3.3.1"
 }