rado 0.1.24 → 0.1.26

package/dist/driver/better-sqlite3.d.ts

@@ -1,16 +1,14 @@
 import type { Database } from 'better-sqlite3';
 import { Driver } from '../lib/Driver';
 import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
+import { CompiledStatement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class BetterSqlite3Driver extends Driver.Sync {
     db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database);
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
-    values([sql, params]: Statement.Compiled): Array<Array<any>>;
-    execute([sql, params]: Statement.Compiled): void;
-    mutate([sql, params]: Statement.Compiled): {
-        rowsAffected: number;
-    };
+    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }

package/dist/driver/better-sqlite3.js

@@ -2,31 +2,38 @@
 import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+var PreparedStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  all(params = []) {
+    return this.stmt.all(...params);
+  }
+  run(params = []) {
+    return { rowsAffected: this.stmt.run(...params).changes };
+  }
+  get(params = []) {
+    return this.stmt.get(...params);
+  }
+  execute(params = []) {
+    this.stmt.run(...params);
+  }
+};
 var BetterSqlite3Driver = class extends Driver.Sync {
   constructor(db) {
     super(new SqliteFormatter());
     this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
   }
-  rows([sql, params]) {
-    return this.db.prepare(sql).all(...params);
-  }
-  values([sql, params]) {
-    return this.db.prepare(sql).raw().all(...params);
-  }
-  execute([sql, params]) {
-    this.db.prepare(sql).run(...params);
-  }
-  mutate([sql, params]) {
-    const { changes } = this.db.prepare(sql).run(...params);
-    return { rowsAffected: changes };
+  tableData;
+  indexData;
+  prepareStatement(stmt) {
+    return new PreparedStatement(this.db.prepare(stmt.sql));
   }
   schemaInstructions(tableName) {
-    const columnData = this.rows(
-      SqliteSchema.tableData(tableName).compile(this.formatter)
-    );
-    const indexData = this.rows(
-      SqliteSchema.indexData(tableName).compile(this.formatter)
-    );
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {

package/dist/driver/sql.js.d.ts

@@ -1,16 +1,14 @@
 import type { Database } from 'sql.js';
 import { Driver } from '../lib/Driver';
 import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
+import { CompiledStatement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class SqlJsDriver extends Driver.Sync {
     db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database);
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
-    values([sql, params]: Statement.Compiled): Array<Array<any>>;
-    execute([sql, params]: Statement.Compiled): void;
-    mutate([sql, params]: Statement.Compiled): {
-        rowsAffected: number;
-    };
+    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }

package/dist/driver/sql.js.js

@@ -2,41 +2,44 @@
 import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var SqlJsDriver = class extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
+var PreparedStatement = class {
+  constructor(db, stmt) {
     this.db = db;
+    this.stmt = stmt;
   }
-  rows([sql, params]) {
-    const stmt = this.db.prepare(sql);
-    stmt.bind(params);
+  all(params) {
+    this.stmt.bind(params);
     const res = [];
-    while (stmt.step())
-      res.push(stmt.getAsObject());
+    while (this.stmt.step())
+      res.push(this.stmt.getAsObject());
     return res;
   }
-  values([sql, params]) {
-    const stmt = this.db.prepare(sql);
-    stmt.bind(params);
-    const res = [];
-    while (stmt.step())
-      res.push(stmt.get());
-    return res;
+  run(params) {
+    this.stmt.run(params);
+    return { rowsAffected: this.db.getRowsModified() };
   }
-  execute([sql, params]) {
-    this.db.prepare(sql).run(params);
+  get(params) {
+    return this.all(params)[0];
   }
-  mutate([sql, params]) {
-    this.db.prepare(sql).run(params);
-    return { rowsAffected: this.db.getRowsModified() };
+  execute(params) {
+    this.stmt.run(params);
+  }
+};
+var SqlJsDriver = class extends Driver.Sync {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+  }
+  tableData;
+  indexData;
+  prepareStatement(stmt) {
+    return new PreparedStatement(this.db, this.db.prepare(stmt.sql));
   }
   schemaInstructions(tableName) {
-    const columnData = this.rows(
-      SqliteSchema.tableData(tableName).compile(this.formatter)
-    );
-    const indexData = this.rows(
-      SqliteSchema.indexData(tableName).compile(this.formatter)
-    );
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {

package/dist/driver/sqlite3.d.ts

@@ -2,18 +2,16 @@ import type { Database } from 'sqlite3';
 import { Driver } from '../lib/Driver';
 import { Query } from '../lib/Query';
 import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
+import { CompiledStatement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class Sqlite3Driver 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: Database);
-    executeQuery<T>(query: Query<T>): Promise<T>;
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Promise<Array<T>>;
-    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-    execute([sql, params]: Statement.Compiled): Promise<void>;
-    mutate([sql, params]: Statement.Compiled): Promise<{
-        rowsAffected: number;
-    }>;
+    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
+    prepareStatement(stmt: CompiledStatement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: Driver.Async, release: () => Promise<void>];
 }

package/dist/driver/sqlite3.js

@@ -2,20 +2,13 @@
 import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var Sqlite3Driver = class extends Driver.Async {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-  }
-  lock;
-  async executeQuery(query) {
-    await this.lock;
-    return super.executeQuery(query);
+var PreparedStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
   }
-  rows([sql, params]) {
+  all(params) {
     return new Promise((resolve, reject) => {
-      const stmt = this.db.prepare(sql);
-      stmt.all(params, (err, rows) => {
+      this.stmt.all(params, (err, rows) => {
         if (err)
           reject(err);
         else
@@ -23,39 +16,57 @@ var Sqlite3Driver = class extends Driver.Async {
       });
     });
   }
-  async values(stmt) {
-    const rows = await this.rows(stmt);
-    return rows.map(Object.values);
+  run(params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.run(params, function(err) {
+        if (err)
+          reject(err);
+        else
+          resolve({ rowsAffected: this.changes });
+      });
+    });
   }
-  execute([sql, params]) {
+  get(params) {
     return new Promise((resolve, reject) => {
-      const stmt = this.db.prepare(sql);
-      stmt.run(params, (err) => {
+      this.stmt.get(params, (err, row) => {
         if (err)
           reject(err);
         else
-          resolve();
+          resolve(row);
       });
     });
   }
-  mutate([sql, params]) {
+  execute(params) {
     return new Promise((resolve, reject) => {
-      const stmt = this.db.prepare(sql);
-      stmt.run(params, function(err) {
+      this.stmt.run(params, (err) => {
         if (err)
           reject(err);
         else
-          resolve({ rowsAffected: this.changes });
+          resolve();
       });
     });
   }
+};
+var Sqlite3Driver = class extends Driver.Async {
+  constructor(db) {
+    super(new SqliteFormatter());
+    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.rows(
-      SqliteSchema.tableData(tableName).compile(this.formatter)
-    );
-    const indexData = await this.rows(
-      SqliteSchema.indexData(tableName).compile(this.formatter)
-    );
+    const columnData = await this.tableData(tableName);
+    const indexData = await this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
   isolate() {

package/dist/lib/Cursor.d.ts

@@ -8,6 +8,7 @@ import { Update as UpdateSet } from './Update';
 export declare class Cursor<T> {
     [Selection.__cursorType](): T;
     constructor(query: Query<T>);
+    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
     query(): Query<T>;
     toJSON(): Query<T>;
 }
@@ -19,7 +20,7 @@ export declare namespace Cursor {
     class Filterable<T> extends Limitable<T> {
         where(...where: Array<EV<boolean>>): Filterable<T>;
     }
-    class Delete<T> extends Filterable<{
+    class Delete extends Filterable<{
         rowsAffected: number;
     }> {
         query(): Query.Delete;

package/dist/lib/Cursor.js

@@ -15,6 +15,9 @@ var Cursor = class {
       value: () => query
     });
   }
+  static all(strings, ...params) {
+    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
+  }
   query() {
     throw new Error("Not implemented");
   }

package/dist/lib/Driver.d.ts

@@ -1,8 +1,9 @@
 import { Cursor } from './Cursor';
+import { Expr } from './Expr';
 import { Formatter } from './Formatter';
 import { Query } from './Query';
 import { SchemaInstructions } from './Schema';
-import { Statement } from './Statement';
+import { CompiledStatement } from './Statement';
 import { Table } from './Table';
 declare class Callable extends Function {
     constructor(fn: Function);
@@ -10,12 +11,18 @@ declare class Callable extends Function {
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, CompiledStatement];
     all(...args: Array<any>): any;
     get(...args: Array<any>): any;
     sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
     executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: Query<any>): any;
 }
+type ParamTypes<Params extends [...any[]]> = {
+    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
+} & {
+    length: Params['length'];
+};
 interface SyncDriver {
     <T>(query: Cursor<T>): T;
     <T>(...queries: Array<Cursor<any>>): T;
@@ -23,17 +30,13 @@ interface SyncDriver {
 }
 declare abstract class SyncDriver extends DriverBase {
     transactionId: number;
-    abstract rows(stmt: Statement.Compiled): Array<object>;
-    abstract values(stmt: Statement.Compiled): Array<Array<any>>;
-    abstract execute(stmt: Statement.Compiled): void;
-    abstract mutate(stmt: Statement.Compiled): {
-        rowsAffected: number;
-    };
+    abstract prepareStatement(stmt: CompiledStatement): SyncPreparedStatement;
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>): T;
+    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
     all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): T;
     all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
     get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
     get<T>(cursor: Cursor<T>): T;
@@ -41,6 +44,14 @@ declare abstract class SyncDriver extends DriverBase {
     transaction<T>(run: (query: SyncDriver) => T): T;
     toAsync(): SyncWrapper;
 }
+interface SyncPreparedStatement {
+    run(params?: Array<any>): {
+        rowsAffected: number;
+    };
+    all<T>(params?: Array<any>): Array<T>;
+    get<T>(params?: Array<any>): T;
+    execute(params?: Array<any>): void;
+}
 interface AsyncDriver {
     <T>(query: Cursor<T>): Promise<T>;
     <T>(...queries: Array<Cursor<any>>): Promise<T>;
@@ -49,15 +60,11 @@ interface AsyncDriver {
 declare abstract class AsyncDriver extends DriverBase {
     transactionId: number;
     abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
-    abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-    abstract execute(stmt: Statement.Compiled): Promise<void>;
-    abstract mutate(stmt: Statement.Compiled): Promise<{
-        rowsAffected: number;
-    }>;
+    abstract prepareStatement(stmt: CompiledStatement): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-    executeQuery<T>(query: Query<T>): Promise<T>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
     all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
     all<T>(cursor: Cursor<T>): Promise<T>;
     all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
@@ -70,20 +77,29 @@ declare class SyncWrapper extends AsyncDriver {
     private sync;
     lock: Promise<void> | undefined;
     constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>): Promise<T>;
-    rows(stmt: Statement.Compiled): Promise<Array<object>>;
-    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-    execute(stmt: Statement.Compiled): Promise<void>;
-    mutate(stmt: Statement.Compiled): Promise<{
-        rowsAffected: number;
-    }>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    prepareStatement(stmt: CompiledStatement): AsyncPreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: AsyncDriver, release: () => Promise<void>];
 }
+interface AsyncPreparedStatement {
+    run(params?: Array<any>): Promise<{
+        rowsAffected: number;
+    }>;
+    all<T>(params?: Array<any>): Promise<Array<T>>;
+    get<T>(params?: Array<any>): Promise<T>;
+    execute(params?: Array<any>): Promise<void>;
+}
 export declare namespace Driver {
     type Sync = SyncDriver;
     const Sync: typeof SyncDriver;
+    namespace Sync {
+        type PreparedStatement = SyncPreparedStatement;
+    }
     type Async = AsyncDriver;
     const Async: typeof AsyncDriver;
+    namespace Async {
+        type PreparedStatement = AsyncPreparedStatement;
+    }
 }
 export {};

package/dist/lib/Driver.js

@@ -1,5 +1,7 @@
 // src/lib/Driver.ts
 import { Cursor } from "./Cursor.js";
+import { Expr, ExprData } from "./Expr.js";
+import { ParamData } from "./Param.js";
 import { Query, QueryType } from "./Query.js";
 import { Schema } from "./Schema.js";
 var Callable = class extends Function {
@@ -31,6 +33,16 @@ var DriverBase = class extends Callable {
     });
     this.formatter = formatter;
   }
+  compile(create) {
+    const { length } = create;
+    const paramNames = Array.from({ length }, (_, i) => `p${i}`);
+    const params = paramNames.map(
+      (name) => new Expr(ExprData.Param(ParamData.Named(name)))
+    );
+    const cursor = create(...params);
+    const query = cursor.query();
+    return [query, this.formatter.compile(query)];
+  }
   all(...args) {
     const [input, ...rest] = args;
     if (input instanceof Cursor.SelectSingle)
@@ -56,6 +68,16 @@ var DriverBase = class extends Callable {
 };
 var SyncDriver = class extends DriverBase {
   transactionId = 0;
+  prepare(create) {
+    const [query, compiled] = this.compile(create);
+    const prepared = this.prepareStatement(compiled);
+    return (...params) => {
+      const namedParams = Object.fromEntries(
+        params.map((value, i) => [`p${i}`, value])
+      );
+      return this.executeQuery(query, prepared, compiled.params(namedParams));
+    };
+  }
   migrateSchema(...tables) {
     const queries = [];
     for (const table of Object.values(tables)) {
@@ -71,7 +93,7 @@ var SyncDriver = class extends DriverBase {
     }
     return this.executeQuery(Query.Batch({ queries }));
   }
-  executeQuery(query) {
+  executeQuery(query, stmt, params) {
     switch (query.type) {
       case QueryType.Batch:
         let result;
@@ -86,24 +108,26 @@ var SyncDriver = class extends DriverBase {
           return result;
         });
       default:
-        const stmt = this.formatter.compile(query);
+        const compiled = stmt ? void 0 : this.formatter.compile(query);
+        stmt = stmt || this.prepareStatement(compiled);
+        params = params || compiled.params();
         if ("selection" in query) {
-          const res = this.values(stmt).map(([item]) => JSON.parse(item).result);
+          const res = stmt.all(params).map((row) => JSON.parse(row.result).result);
           if (query.singleResult)
             return res[0];
           return res;
         } else if (query.type === QueryType.Raw) {
           switch (query.expectedReturn) {
             case "row":
-              return this.rows(stmt)[0];
+              return stmt.all(params)[0];
             case "rows":
-              return this.rows(stmt);
+              return stmt.all(params);
             default:
-              this.execute(stmt);
+              stmt.execute(params);
               return void 0;
           }
         } else {
-          return this.mutate(stmt);
+          return stmt.run(params);
         }
     }
   }
@@ -137,6 +161,16 @@ var SyncDriver = class extends DriverBase {
 };
 var AsyncDriver = class extends DriverBase {
   transactionId = 0;
+  prepare(create) {
+    const [query, compiled] = this.compile(create);
+    const prepared = this.prepareStatement(compiled);
+    return (...params) => {
+      const namedParams = Object.fromEntries(
+        params.map((value, i) => [`p${i}`, value])
+      );
+      return this.executeQuery(query, prepared, compiled.params(namedParams));
+    };
+  }
   async migrateSchema(...tables) {
     const queries = [];
     for (const table of Object.values(tables)) {
@@ -152,7 +186,7 @@ var AsyncDriver = class extends DriverBase {
     }
     return this.executeQuery(Query.Batch({ queries }));
   }
-  async executeQuery(query) {
+  async executeQuery(query, stmt, params) {
     switch (query.type) {
       case QueryType.Batch:
         let result;
@@ -167,10 +201,12 @@ var AsyncDriver = class extends DriverBase {
           return result;
         });
       default:
-        const stmt = this.formatter.compile(query);
+        const compiled = stmt ? void 0 : this.formatter.compile(query);
+        stmt = stmt || this.prepareStatement(compiled);
+        params = params || compiled.params();
         if ("selection" in query) {
-          const res = (await this.values(stmt)).map(
-            ([item]) => JSON.parse(item).result
+          const res = (await stmt.all(params)).map(
+            (item) => JSON.parse(item.result).result
           );
           if (query.singleResult)
             return res[0];
@@ -178,15 +214,15 @@ var AsyncDriver = class extends DriverBase {
         } else if (query.type === QueryType.Raw) {
           switch (query.expectedReturn) {
             case "row":
-              return (await this.rows(stmt))[0];
+              return (await stmt.all(params))[0];
             case "rows":
-              return await this.rows(stmt);
+              return await stmt.all(params);
             default:
-              await this.execute(stmt);
+              await stmt.execute(params);
               return void 0;
           }
         } else {
-          return await this.mutate(stmt);
+          return await stmt.run(params);
         }
     }
   }
@@ -218,27 +254,35 @@ var AsyncDriver = class extends DriverBase {
     }
   }
 };
+var SyncPreparedStatementWrapper = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  async run(params) {
+    return this.stmt.run(params);
+  }
+  async all(params) {
+    return this.stmt.all(params);
+  }
+  async get(params) {
+    return this.stmt.get(params);
+  }
+  async execute(params) {
+    return this.stmt.execute(params);
+  }
+};
 var SyncWrapper = class extends AsyncDriver {
   constructor(sync) {
     super(sync.formatter);
     this.sync = sync;
   }
   lock;
-  async executeQuery(query) {
+  async executeQuery(query, stmt, params) {
     await this.lock;
-    return super.executeQuery(query);
-  }
-  async rows(stmt) {
-    return this.sync.rows(stmt);
-  }
-  async values(stmt) {
-    return this.sync.values(stmt);
-  }
-  async execute(stmt) {
-    return this.sync.execute(stmt);
+    return super.executeQuery(query, stmt, params);
   }
-  async mutate(stmt) {
-    return this.sync.mutate(stmt);
+  prepareStatement(stmt) {
+    return new SyncPreparedStatementWrapper(this.sync.prepareStatement(stmt));
   }
   async schemaInstructions(tableName) {
     return this.sync.schemaInstructions(tableName);

package/dist/lib/Formatter.d.ts

@@ -16,10 +16,11 @@ export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
     abstract escapeIdentifier(ident: string): string;
+    abstract formatParamValue(paramValue: any): any;
     abstract formatSqlAccess(on: Statement, field: string): Statement;
     abstract formatJsonAccess(on: Statement, field: string): Statement;
     formatAccess(on: Statement, field: string, formatAsJson?: boolean): Statement;
-    compile<T>(query: Query<T>, formatInline?: boolean): Statement.Compiled;
+    compile<T>(query: Query<T>, formatInline?: boolean): import("./Statement").CompiledStatement;
     format<T>(query: Query<T>, ctx?: FormatContext): Statement;
     formatSelect(query: Query.Select, ctx: FormatContext): Statement;
     formatInsert(query: Query.Insert, ctx: FormatContext): Statement;

package/dist/lib/Formatter.js

@@ -1,6 +1,6 @@
 // src/lib/Formatter.ts
 import { ColumnType } from "./Column.js";
-import { BinOp, ExprData, ExprType, UnOp } from "./Expr.js";
+import { BinOp, Expr, ExprData, ExprType, UnOp } from "./Expr.js";
 import { OrderDirection } from "./OrderBy.js";
 import { ParamType } from "./Param.js";
 import { Query, QueryType } from "./Query.js";
@@ -9,6 +9,7 @@ import {
   call,
   identifier,
   newline,
+  param,
   parenthesis,
   raw,
   separated,
@@ -163,7 +164,14 @@ var Formatter = class {
     );
   }
   formatRaw({ strings, params }, ctx) {
-    return Statement.tag(strings, ...params);
+    return Statement.tag(
+      strings,
+      params.map((param2) => {
+        if (param2 instanceof Expr)
+          return this.formatExpr(param2.expr, ctx);
+        return this.formatValue(param2, ctx);
+      })
+    );
   }
   formatColumn(column) {
     return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "UNIQUE").addIf(column.autoIncrement, "AUTOINCREMENT").addIf(column.primaryKey, "PRIMARY KEY").addIf(!column.nullable, "NOT NULL").addIf(
@@ -209,6 +217,8 @@ var Formatter = class {
     );
   }
   formatColumnValue(column, columnValue) {
+    if (columnValue instanceof Expr)
+      return this.formatExprValue(columnValue.expr, {});
     const isNull = columnValue === void 0 || columnValue === null;
     const isOptional = column.nullable || column.autoIncrement || column.primaryKey;
     if (isNull) {
@@ -231,7 +241,7 @@ var Formatter = class {
       case ColumnType.Boolean:
         if (typeof columnValue !== "boolean")
           throw new TypeError(`Expected boolean for column ${column.name}`);
-        return value(columnValue);
+        return raw(this.escapeValue(columnValue));
       case ColumnType.Json:
         if (typeof columnValue !== "object")
           throw new TypeError(`Expected object for column ${column.name}`);
@@ -409,7 +419,7 @@ var Formatter = class {
           case ParamType.Value:
             return this.formatValue(expr.param.value, ctx);
           case ParamType.Named:
-            throw new Error("todo");
+            return param(expr.param.name);
         }
       case ExprType.Field:
         return this.formatField(expr.expr, expr.field, ctx);

package/dist/lib/Index.d.ts

@@ -1,8 +1,8 @@
 import { Expr, ExprData } from './Expr';
 interface PartialIndexData {
     on: Array<ExprData>;
-    where?: ExprData;
     unique?: boolean;
+    where?: ExprData;
 }
 export interface IndexData extends PartialIndexData {
     name: string;
@@ -10,8 +10,8 @@ export interface IndexData extends PartialIndexData {
 export declare class Index {
     data: PartialIndexData;
     constructor(data: PartialIndexData);
-    where(where: Expr<boolean>): Index;
     unique(): Index;
+    where(where: Expr<boolean>): Index;
 }
 export declare function index(...on: Array<Expr<any>>): Index;
 export {};

package/dist/lib/Index.js

@@ -4,12 +4,12 @@ var Index = class {
   constructor(data) {
     this.data = data;
   }
-  where(where) {
-    return new Index({ ...this.data, where: ExprData.create(where) });
-  }
   unique() {
     return new Index({ ...this.data, unique: true });
   }
+  where(where) {
+    return new Index({ ...this.data, where: ExprData.create(where) });
+  }
 };
 function index(...on) {
   return new Index({ on: on.map(ExprData.create) });

package/dist/lib/Ops.d.ts

@@ -4,5 +4,5 @@ export declare function selectAll<Row>(table: Table<Row>): Cursor.SelectMultiple
 export declare function selectFirst<Row>(table: Table<Row>): Cursor.SelectSingle<Row>;
 export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
 export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete<Row>;
+export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
 export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/lib/Param.d.ts

@@ -1,3 +1,4 @@
+import { Expr } from './Expr';
 export declare enum ParamType {
     Value = "Value",
     Named = "Named"
@@ -13,3 +14,7 @@ export declare const ParamData: {
     Value(value: any): ParamData;
     Named(name: string): ParamData;
 };
+export type Params<T> = {
+    [K in keyof T]: Expr<T[K]>;
+};
+export declare function createParams<T>(): Params<T>;

package/dist/lib/Param.js

@@ -1,4 +1,5 @@
 // src/lib/Param.ts
+import { Expr, ExprData } from "./Expr.js";
 var ParamType = /* @__PURE__ */ ((ParamType2) => {
   ParamType2["Value"] = "Value";
   ParamType2["Named"] = "Named";
@@ -12,7 +13,15 @@ var ParamData = {
     return { type: "Named" /* Named */, name };
   }
 };
+function createParams() {
+  return new Proxy({}, {
+    get(target, prop) {
+      return new Expr(ExprData.Param(ParamData.Named(prop)));
+    }
+  });
+}
 export {
   ParamData,
-  ParamType
+  ParamType,
+  createParams
 };

package/dist/lib/Sanitizer.d.ts

@@ -1,4 +1,5 @@
 export interface Sanitizer {
     escapeValue(value: any): string;
     escapeIdentifier(ident: string): string;
+    formatParamValue(paramValue: any): any;
 }

package/dist/lib/Schema.js

@@ -27,7 +27,7 @@ var Schema;
       } else if (!schemaCol) {
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
-        const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        const { sql: instruction } = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
@@ -45,7 +45,7 @@ var Schema;
       } else if (!schemaIndex) {
         res.unshift(Query.DropIndex({ table: schema, name: indexName }));
       } else {
-        const [instruction] = formatter.formatCreateIndex(
+        const { sql: instruction } = formatter.formatCreateIndex(
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {

package/dist/lib/Statement.d.ts

@@ -1,8 +1,10 @@
+import { ParamData } from './Param';
 import { Sanitizer } from './Sanitizer';
 declare enum TokenType {
     Raw = "Raw",
     Identifier = "Identifier",
     Value = "Value",
+    Param = "Param",
     Indent = "Indent",
     Dedent = "Dedent"
 }
@@ -15,6 +17,7 @@ declare class Token {
     static Dedent(): Token;
     static Identifier(data: string): Token;
     static Value(data: any): Token;
+    static Param(name: string): Token;
 }
 export interface CompileOptions {
     formatInline?: boolean;
@@ -25,7 +28,7 @@ export declare class Statement {
     constructor(tokens: Array<Token>);
     concat(...tokens: Array<Token | Statement>): Statement;
     static create(from: string | Statement): Statement;
-    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
+    static tag(strings: ReadonlyArray<string>, params: Array<Statement>): Statement;
     space(): Statement;
     call(method: string, ...args: Array<Statement>): Statement;
     addCall(method: string, ...args: Array<Statement>): Statement;
@@ -39,21 +42,28 @@ export declare class Statement {
     addIdentifier(name: string): Statement;
     value(value: any): Statement;
     addValue(value: any): Statement;
+    param(name: string): Statement;
+    addParam(name: string): Statement;
     raw(query: string): Statement;
     parenthesis(inner: string | Statement): Statement;
     addParenthesis(stmnt: string | Statement): Statement;
     separated(input: Array<Statement>, separator?: string): Statement;
     addSeparated(input: Array<Statement>, separator?: string): Statement;
     isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
+    compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
 }
-export declare namespace Statement {
-    type Compiled = [sql: string, params: Array<any>];
+export declare class CompiledStatement {
+    sql: string;
+    private paramData;
+    constructor(sql: string, paramData: Array<ParamData>);
+    params(input?: Record<string, any>): Array<any>;
+    toString(): string;
 }
 export declare function newline(): Statement;
 export declare function raw(raw: string): Statement;
 export declare function identifier(name: string): Statement;
 export declare function value(value: any): Statement;
+export declare function param(name: string): Statement;
 export declare function empty(): Statement;
 export declare function parenthesis(stmnt: Statement): Statement;
 export declare function call(method: string, ...args: Array<Statement>): Statement;

package/dist/lib/Statement.js

@@ -1,4 +1,5 @@
 // src/lib/Statement.ts
+import { ParamData, ParamType } from "./Param.js";
 var Token = class {
   constructor(type, data) {
     this.type = type;
@@ -19,6 +20,9 @@ var Token = class {
   static Value(data) {
     return new Token("Value" /* Value */, data);
   }
+  static Param(name) {
+    return new Token("Param" /* Param */, name);
+  }
 };
 var SEPARATE = ",";
 var WHITESPACE = " ";
@@ -37,9 +41,12 @@ var Statement = class {
   static create(from) {
     return typeof from === "string" ? raw(from) : from;
   }
-  static tag(strings, ...params) {
+  static tag(strings, params) {
     return new Statement(
-      strings.flatMap((s, i) => [Token.Raw(s), Token.Value(params[i])]).slice(0, -1)
+      strings.flatMap((s, i) => {
+        const param2 = params[i];
+        return [Token.Raw(s)].concat(param2 ? param2.tokens : []);
+      })
     );
   }
   space() {
@@ -93,6 +100,12 @@ var Statement = class {
   addValue(value2) {
     return this.space().value(value2);
   }
+  param(name) {
+    return this.concat(Token.Param(name));
+  }
+  addParam(name) {
+    return this.space().param(name);
+  }
   raw(query) {
     if (!query)
       return this;
@@ -118,7 +131,7 @@ var Statement = class {
     return this.tokens.length === 0 || this.tokens.length === 1 && this.tokens[0].type === "Raw" /* Raw */ && this.tokens[0].data === "";
   }
   compile(sanitizer, formatInline = false) {
-    let sql = "", params = [], indent = "";
+    let sql = "", paramData = [], indent = "";
     for (const token of this.tokens) {
       switch (token.type) {
         case "Raw" /* Raw */:
@@ -135,9 +148,15 @@ var Statement = class {
             sql += sanitizer.escapeValue(token.data);
           } else {
             sql += "?";
-            params.push(token.data === void 0 ? null : token.data);
+            paramData.push(
+              ParamData.Value(sanitizer.formatParamValue(token.data))
+            );
           }
           break;
+        case "Param" /* Param */:
+          sql += "?";
+          paramData.push(ParamData.Named(token.data));
+          break;
         case "Indent" /* Indent */:
           indent += "  ";
           break;
@@ -146,7 +165,26 @@ var Statement = class {
           break;
       }
     }
-    return [sql, params];
+    return new CompiledStatement(sql, paramData);
+  }
+};
+var CompiledStatement = class {
+  constructor(sql, paramData) {
+    this.sql = sql;
+    this.paramData = paramData;
+  }
+  params(input) {
+    return this.paramData.map((param2) => {
+      if (param2.type === ParamType.Named) {
+        if (input && param2.name in input)
+          return input[param2.name];
+        throw new TypeError(`Missing parameter ${param2.name}`);
+      }
+      return param2.value;
+    });
+  }
+  toString() {
+    return this.sql;
   }
 };
 function newline() {
@@ -161,6 +199,9 @@ function identifier(name) {
 function value(value2) {
   return new Statement([Token.Value(value2)]);
 }
+function param(name) {
+  return new Statement([Token.Param(name)]);
+}
 function empty() {
   return new Statement([]);
 }
@@ -174,11 +215,13 @@ function separated(input, separator = SEPARATE) {
   return empty().separated(input, separator);
 }
 export {
+  CompiledStatement,
   Statement,
   call,
   empty,
   identifier,
   newline,
+  param,
   parenthesis,
   raw,
   separated,

package/dist/lib/Table.d.ts

@@ -1,6 +1,6 @@
 import { Column, PrimaryKey } from './Column';
 import { Cursor } from './Cursor';
-import { Expr } from './Expr';
+import { EV, Expr } from './Expr';
 import { Fields } from './Fields';
 import { Index } from './Index';
 import { Schema } from './Schema';
@@ -12,6 +12,7 @@ export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>>
     insertOne(record: Table.Insert<T>): Cursor.Batch<Table.Normalize<T>>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
     set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
+    delete(): Cursor.Delete;
     createTable(): Cursor.Create;
     as(alias: string): this;
     alias(): Record<string, this>;
@@ -21,7 +22,7 @@ export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>>
 }
 export declare namespace Table {
     type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: U[P];
+        [P in keyof U]: EV<U[P]>;
     } : never;
     type OptionalKeys<T> = {
         [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
@@ -39,15 +40,15 @@ export declare namespace Table {
     export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
     export {};
 }
-export interface TableOptions<T> {
+export type TableOptions<T, R> = {
     name: string;
     alias?: string;
     columns: {
         [K in keyof T]: Column<T[K]>;
     };
     indexes?: (this: Fields<T>) => Record<string, Index>;
-}
-export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
+};
+export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
 export declare namespace table {
     export type infer<T> = Table.Infer<T>;
     type Extensions<T> = {

package/dist/lib/Table.js

@@ -52,6 +52,9 @@ var Table = class extends Cursor.SelectMultiple {
       })
     ).set(data);
   }
+  delete() {
+    return new Cursor.Delete(Query.Delete({ table: this.schema() }));
+  }
   createTable() {
     return new Cursor.Create(this.schema());
   }
@@ -98,13 +101,7 @@ function table(options) {
       ) : {}
     ).map(([key, index]) => {
       const indexName = `${schema.name}.${key}`;
-      return [
-        indexName,
-        {
-          name: indexName,
-          ...index.data
-        }
-      ];
+      return [indexName, { name: indexName, ...index.data }];
     })
   );
   return new Table({

package/dist/sqlite/SqliteFormatter.d.ts

@@ -2,6 +2,7 @@ import { ExprData } from '../lib/Expr';
 import { FormatContext, Formatter } from '../lib/Formatter';
 import { Statement } from '../lib/Statement';
 export declare class SqliteFormatter extends Formatter {
+    formatParamValue(paramValue: any): any;
     escapeValue(value: any): string;
     escapeIdentifier(input: string): string;
     escapeString(input: string): string;

package/dist/sqlite/SqliteFormatter.js

@@ -15,6 +15,17 @@ function escapeWithin(input, outer) {
   return buf;
 }
 var SqliteFormatter = class extends Formatter {
+  formatParamValue(paramValue) {
+    if (paramValue === null || paramValue === void 0)
+      return null;
+    if (typeof paramValue === "boolean")
+      return paramValue ? 1 : 0;
+    if (typeof paramValue === "number")
+      return paramValue;
+    if (typeof paramValue === "string")
+      return paramValue;
+    return JSON.stringify(paramValue);
+  }
   escapeValue(value) {
     if (value === null || value === void 0)
       return "null";

package/dist/sqlite/SqliteSchema.d.ts

@@ -1,5 +1,6 @@
+import { Cursor } from '../lib/Cursor';
+import { Expr } from '../lib/Expr';
 import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
 export declare namespace SqliteSchema {
     type Column = {
         cid: number;
@@ -16,8 +17,8 @@ export declare namespace SqliteSchema {
         rootpage: number;
         sql: string;
     }
-    function tableData(tableName: string): Statement;
-    function indexData(tableName: string): Statement;
+    function tableData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Column>>;
+    function indexData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Index>>;
     function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
     function columnInstruction(column: Column): [string, string];
     function indexInstruction(index: Index): [string, string];

package/dist/sqlite/SqliteSchema.js

@@ -1,15 +1,16 @@
 // src/sqlite/SqliteSchema.ts
-import { Statement, identifier, raw } from "../lib/Statement.js";
+import { Cursor } from "../lib/Cursor.js";
+import { identifier, raw } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {
   const formatter = new SqliteFormatter();
   function tableData(tableName) {
-    return Statement.tag`select * from pragma_table_info(${tableName}) order by cid`;
+    return Cursor.all`select * from pragma_table_info(${tableName}) order by cid`;
   }
   SqliteSchema2.tableData = tableData;
   function indexData(tableName) {
-    return Statement.tag`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
+    return Cursor.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
   }
   SqliteSchema2.indexData = indexData;
   function createInstructions(columnData, indexData2) {
@@ -29,7 +30,7 @@ var SqliteSchema;
       identifier(column.name).add(column.type).addIf(column.pk === 1, "PRIMARY KEY").addIf(column.notnull === 1, "NOT NULL").addIf(
         column.dflt_value !== null,
         raw("DEFAULT").addParenthesis(column.dflt_value)
-      ).compile(formatter)[0]
+      ).compile(formatter).sql
     ];
   }
   SqliteSchema2.columnInstruction = columnInstruction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "license": "MIT",
   "type": "module",
   "exports": {