rado 0.2.36 → 0.2.39

package/dist/define/Schema.d.ts

@@ -7,6 +7,6 @@ export interface SchemaInstructions {
 }
 export declare namespace Schema {
     function create(schema: TableData): QueryData.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData): Array<QueryData>;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData, verbose?: boolean): Array<QueryData>;
 }
 export declare function schema(...tables: Array<Table<any>>): void;

package/dist/define/Schema.js

@@ -53,7 +53,7 @@ var Schema;
       queries.push(new QueryData.CreateIndex({ table, index }));
     return queries;
   }
-  function upgrade(formatter, local, schema2) {
+  function upgrade(formatter, local, schema2, verbose = true) {
     const columnNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.columns),
       ...Object.keys(schema2.columns)
@@ -67,16 +67,22 @@ var Schema;
         res.push(
           new QueryData.AlterTable({ table: schema2, addColumn: schemaCol })
         );
+        if (verbose)
+          console.log(`Adding column ${columnName}`);
       } else if (!schemaCol) {
         res.push(
           new QueryData.AlterTable({ table: schema2, dropColumn: columnName })
         );
+        if (verbose)
+          console.log(`Removing column ${columnName}`);
       } else {
         const { sql: instruction } = formatter.formatColumn(
           { stmt: new Statement(formatter) },
           { ...schemaCol, references: void 0 }
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          if (verbose)
+            console.log(`Recreating because ${columnName} differs`);
           recreate = true;
         }
       }
@@ -97,13 +103,19 @@ var Schema;
       const schemaIndex = meta.indexes[indexName];
       if (!localInstruction) {
         res.push(new QueryData.CreateIndex({ table: schema2, index: schemaIndex }));
+        if (verbose)
+          console.log(`Adding index ${indexName}`);
       } else if (!schemaIndex) {
         res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
+        if (verbose)
+          console.log(`Removing index ${indexName}`);
       } else {
         const { sql: instruction } = formatter.compile(
           new QueryData.CreateIndex({ table: schema2, index: schemaIndex })
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          if (verbose)
+            console.log(`Recreating index ${indexName}`);
           res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
           res.push(
             new QueryData.CreateIndex({ table: schema2, index: schemaIndex })

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

@@ -1,15 +1,15 @@
 import type { Database } from 'better-sqlite3';
 import { SchemaInstructions } from '../define/Schema.js';
-import { Driver } from '../lib/Driver.js';
+import { Driver, DriverOptions } from '../lib/Driver.js';
 import { Statement } from '../lib/Statement.js';
 import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class BetterSqlite3Driver extends Driver.Sync {
     db: Database;
     tableData: (tableName: string) => Array<SqliteSchema.Column>;
     indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    constructor(db: Database);
+    constructor(db: Database, options?: DriverOptions);
     prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }
-export declare function connect(db: Database): BetterSqlite3Driver;
+export declare function connect(db: Database, options?: DriverOptions): BetterSqlite3Driver;

package/dist/driver/better-sqlite3.js

@@ -1,5 +1,4 @@
 import { Driver } from "../lib/Driver.js";
-import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 class PreparedStatement {
@@ -23,8 +22,8 @@ class PreparedStatement {
   }
 }
 class BetterSqlite3Driver extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
     this.db = db;
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
@@ -32,11 +31,7 @@ class BetterSqlite3Driver extends Driver.Sync {
   tableData;
   indexData;
   prepareStatement(stmt) {
-    try {
-      return new PreparedStatement(this.db.prepare(stmt.sql));
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
+    return new PreparedStatement(this.db.prepare(stmt.sql));
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);
@@ -47,8 +42,8 @@ class BetterSqlite3Driver extends Driver.Sync {
     return this.db.serialize();
   }
 }
-function connect(db) {
-  return new BetterSqlite3Driver(db);
+function connect(db, options) {
+  return new BetterSqlite3Driver(db, options);
 }
 export {
   BetterSqlite3Driver,

package/dist/driver/bun-sqlite.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bun-types" />
 import type { Database } from 'bun:sqlite';
 import { SchemaInstructions } from '../define/Schema.js';
-import { Driver } from '../lib/Driver.js';
+import { Driver, DriverOptions } from '../lib/Driver.js';
 import { Statement } from '../lib/Statement.js';
 import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class BunSqliteDriver extends Driver.Sync {
@@ -11,8 +11,8 @@ export declare class BunSqliteDriver extends Driver.Sync {
     lastChanges: () => {
         rowsAffected: number;
     };
-    constructor(db: Database);
+    constructor(db: Database, options?: DriverOptions);
     prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
 }
-export declare function connect(db: Database): BunSqliteDriver;
+export declare function connect(db: Database, options?: DriverOptions): BunSqliteDriver;

package/dist/driver/bun-sqlite.js

@@ -1,7 +1,6 @@
 import { QueryData } from "../define/Query.js";
 import { SelectFirst } from "../define/query/Select.js";
 import { Driver } from "../lib/Driver.js";
-import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 class PreparedStatement {
@@ -28,8 +27,8 @@ class PreparedStatement {
   }
 }
 class BunSqliteDriver extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
     this.db = db;
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
@@ -47,11 +46,7 @@ class BunSqliteDriver extends Driver.Sync {
   indexData;
   lastChanges;
   prepareStatement(stmt) {
-    try {
-      return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
+    return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);
@@ -59,8 +54,8 @@ class BunSqliteDriver extends Driver.Sync {
     return SqliteSchema.createInstructions(columnData, indexData);
   }
 }
-function connect(db) {
-  return new BunSqliteDriver(db);
+function connect(db, options) {
+  return new BunSqliteDriver(db, options);
 }
 export {
   BunSqliteDriver,

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

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

package/dist/driver/sql.js.js

@@ -1,5 +1,4 @@
 import { Driver } from "../lib/Driver.js";
-import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 class PreparedStatement {
@@ -34,22 +33,18 @@ class PreparedStatement {
   }
 }
 class SqlJsDriver extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
     this.db = db;
   }
   tableData;
   indexData;
   prepareStatement(stmt, discardAfter) {
-    try {
-      return new PreparedStatement(
-        this.db,
-        this.db.prepare(stmt.sql),
-        discardAfter
-      );
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
+    return new PreparedStatement(
+      this.db,
+      this.db.prepare(stmt.sql),
+      discardAfter
+    );
   }
   schemaInstructions(tableName) {
     this.tableData = this.tableData || (this.tableData = this.prepare(SqliteSchema.tableData));
@@ -62,8 +57,8 @@ class SqlJsDriver extends Driver.Sync {
     return this.db.export();
   }
 }
-function connect(db) {
-  return new SqlJsDriver(db);
+function connect(db, options) {
+  return new SqlJsDriver(db, options);
 }
 export {
   SqlJsDriver,

package/dist/driver/sqlite3.d.ts

@@ -1,7 +1,7 @@
 import type { Database } from 'sqlite3';
 import { QueryData } from '../define/Query.js';
 import { SchemaInstructions } from '../define/Schema.js';
-import { Driver } from '../lib/Driver.js';
+import { Driver, DriverOptions } from '../lib/Driver.js';
 import { Statement } from '../lib/Statement.js';
 import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class Sqlite3Driver extends Driver.Async {
@@ -9,10 +9,10 @@ export declare class Sqlite3Driver extends Driver.Async {
     lock: Promise<void> | undefined;
     tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
     indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
-    constructor(db: Database);
+    constructor(db: Database, 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>];
 }
-export declare function connect(db: Database): Sqlite3Driver;
+export declare function connect(db: Database, options?: DriverOptions): Sqlite3Driver;

package/dist/driver/sqlite3.js

@@ -1,5 +1,4 @@
 import { Driver } from "../lib/Driver.js";
-import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 class PreparedStatement {
@@ -7,7 +6,9 @@ class PreparedStatement {
     this.stmt = stmt;
   }
   async *iterate(params) {
-    let rows = [], done = false, error;
+    let rows = [];
+    let done = false;
+    let error;
     let resolve;
     let promise = new Promise((r) => resolve = r);
     this.stmt.each(
@@ -79,8 +80,8 @@ class PreparedStatement {
   }
 }
 class Sqlite3Driver extends Driver.Async {
-  constructor(db) {
-    super(new SqliteFormatter());
+  constructor(db, options) {
+    super(new SqliteFormatter(), options);
     this.db = db;
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
@@ -93,11 +94,7 @@ class Sqlite3Driver extends Driver.Async {
     return super.executeQuery(query, stmt, params);
   }
   prepareStatement(stmt) {
-    try {
-      return new PreparedStatement(this.db.prepare(stmt.sql));
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
+    return new PreparedStatement(this.db.prepare(stmt.sql));
   }
   async schemaInstructions(tableName) {
     const columnData = await this.tableData(tableName);
@@ -113,8 +110,8 @@ class Sqlite3Driver extends Driver.Async {
     return [connection, release];
   }
 }
-function connect(db) {
-  return new Sqlite3Driver(db);
+function connect(db, options) {
+  return new Sqlite3Driver(db, options);
 }
 export {
   Sqlite3Driver,

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export * from './define/query/Select.js';
 export * from './define/query/TableSelect.js';
 export * from './define/query/Union.js';
 export * from './define/query/Update.js';
-export type { Driver } from './lib/Driver.js';
+export type { Driver, DriverOptions } from './lib/Driver.js';
 export type { FormatContext, Formatter } from './lib/Formatter.js';
 export type { Sanitizer } from './lib/Sanitizer.js';
 export * from './lib/SqlError.js';

package/dist/lib/Driver.d.ts

@@ -6,9 +6,13 @@ import { Select } from '../define/query/Select.js';
 import { Callable } from '../util/Callable.js';
 import { Formatter } from './Formatter.js';
 import { Statement } from './Statement.js';
+export interface DriverOptions {
+    logQuery?: (stmt: Statement, durationMs: number) => void;
+}
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
-    constructor(formatter: Formatter);
+    options: DriverOptions;
+    constructor(formatter: Formatter, options: DriverOptions);
     compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): [QueryData, Statement];
     executeTemplate(expectedReturn: QueryData.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: QueryData): any;
@@ -25,9 +29,11 @@ interface SyncDriver {
 }
 declare abstract class SyncDriver extends DriverBase {
     transactionId: number;
-    constructor(formatter: Formatter);
+    constructor(formatter: Formatter, options?: DriverOptions);
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    createStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
+    handle(stmt: Statement, prepared: SyncPreparedStatement): SyncPreparedStatement;
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
     executeQuery(query: QueryData, stmt?: SyncPreparedStatement, params?: Array<any>): unknown;
@@ -51,10 +57,12 @@ interface AsyncDriver {
 }
 declare abstract class AsyncDriver extends DriverBase {
     transactionId: number;
-    constructor(formatter: Formatter);
+    constructor(formatter: Formatter, options?: DriverOptions);
     abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    createStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    handle(stmt: Statement, prepared: AsyncPreparedStatement): AsyncPreparedStatement;
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => Promise<R>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
     executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;

package/dist/lib/Driver.js

@@ -4,11 +4,12 @@ import { Query, QueryData, QueryType } from "../define/Query.js";
 import { Schema } from "../define/Schema.js";
 import { Table } from "../define/Table.js";
 import { Callable } from "../util/Callable.js";
+import { SqlError } from "./SqlError.js";
 function isTemplateStringsArray(input) {
   return Boolean(Array.isArray(input) && input.raw);
 }
 class DriverBase extends Callable {
-  constructor(formatter) {
+  constructor(formatter, options) {
     super((...args) => {
       const [input, ...rest] = args;
       if (Query.isQuery(input) && rest.length === 0)
@@ -22,6 +23,7 @@ class DriverBase extends Callable {
       );
     });
     this.formatter = formatter;
+    this.options = options;
   }
   compile(create) {
     const { length } = create;
@@ -41,13 +43,41 @@ class DriverBase extends Callable {
 }
 class SyncDriver extends DriverBase {
   transactionId;
-  constructor(formatter) {
-    super(formatter);
+  constructor(formatter, options = {}) {
+    super(formatter, options);
     this.transactionId = 0;
   }
+  createStatement(stmt, discardAfter) {
+    try {
+      return this.handle(stmt, this.prepareStatement(stmt, discardAfter));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  handle(stmt, prepared) {
+    const { logQuery } = this.options;
+    const wrap = (fn) => (...args) => {
+      const startTime = performance.now();
+      try {
+        const res = fn(...args);
+        if (logQuery)
+          logQuery(stmt, performance.now() - startTime);
+        return res;
+      } catch (e) {
+        throw new SqlError(e, stmt.sql);
+      }
+    };
+    return {
+      run: wrap(prepared.run.bind(prepared)),
+      iterate: wrap(prepared.iterate.bind(prepared)),
+      all: wrap(prepared.all.bind(prepared)),
+      get: wrap(prepared.get.bind(prepared)),
+      execute: wrap(prepared.execute.bind(prepared))
+    };
+  }
   prepare(create) {
     const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled, false);
+    const prepared = this.createStatement(compiled, false);
     return (...params) => {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
@@ -90,7 +120,7 @@ class SyncDriver extends DriverBase {
         });
       default:
         const compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled, true);
+        stmt = stmt || this.createStatement(compiled, true);
         params = params || compiled.params();
         if ("selection" in query || query.type === QueryType.Union) {
           const res = stmt.all(params).map((row) => JSON.parse(row.result).result);
@@ -117,7 +147,7 @@ class SyncDriver extends DriverBase {
     }
   }
   *iterate(cursor) {
-    const stmt = this.prepareStatement(
+    const stmt = this.createStatement(
       this.formatter.compile(cursor[Query.Data]),
       true
     );
@@ -155,13 +185,48 @@ class SyncDriver extends DriverBase {
 }
 class AsyncDriver extends DriverBase {
   transactionId;
-  constructor(formatter) {
-    super(formatter);
+  constructor(formatter, options = {}) {
+    super(formatter, options);
     this.transactionId = 0;
   }
+  createStatement(stmt, discardAfter) {
+    try {
+      return this.handle(stmt, this.prepareStatement(stmt, discardAfter));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  handle(stmt, prepared) {
+    const { logQuery } = this.options;
+    const wrap = (fn) => async (...args) => {
+      const startTime = performance.now();
+      try {
+        const res = await fn(...args);
+        if (logQuery)
+          logQuery(stmt, (performance.now() - startTime) / 1e3);
+        return res;
+      } catch (e) {
+        throw new SqlError(e, stmt.sql);
+      }
+    };
+    return {
+      run: wrap(prepared.run.bind(prepared)),
+      async *iterate(params) {
+        const iterator = prepared.iterate(params);
+        try {
+          yield* iterator;
+        } catch (e) {
+          throw new SqlError(e, stmt.sql);
+        }
+      },
+      all: wrap(prepared.all.bind(prepared)),
+      get: wrap(prepared.get.bind(prepared)),
+      execute: wrap(prepared.execute.bind(prepared))
+    };
+  }
   prepare(create) {
     const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled, false);
+    const prepared = this.createStatement(compiled, false);
     return (...params) => {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
@@ -204,7 +269,7 @@ class AsyncDriver extends DriverBase {
         });
       default:
         const compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled, true);
+        stmt = stmt || this.createStatement(compiled, true);
         params = params || compiled.params();
         if ("selection" in query || query.type === QueryType.Union) {
           const res = (await stmt.all(params)).map(
@@ -233,7 +298,7 @@ class AsyncDriver extends DriverBase {
     }
   }
   async *iterate(cursor) {
-    const stmt = this.prepareStatement(
+    const stmt = this.createStatement(
       this.formatter.compile(cursor[Query.Data]),
       true
     );
@@ -292,7 +357,7 @@ class SyncPreparedStatementWrapper {
 }
 class SyncWrapper extends AsyncDriver {
   constructor(sync) {
-    super(sync.formatter);
+    super(sync.formatter, sync.options);
     this.sync = sync;
   }
   lock;

package/dist/lib/Formatter.js

@@ -424,7 +424,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!expr)
       return stmt;
-    stmt.newline().raw("WHERE").space();
+    stmt.addLine("WHERE").space();
     this.formatExprValue(ctx, expr);
     return stmt;
   }
@@ -432,7 +432,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!expr)
       return stmt;
-    stmt.newline().raw("HAVING");
+    stmt.addLine("HAVING");
     this.formatExprValue(ctx, expr);
     return stmt;
   }
@@ -440,7 +440,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!groupBy)
       return stmt;
-    stmt.newline().raw("GROUP BY");
+    stmt.addLine("GROUP BY");
     for (const expr of stmt.separate(groupBy))
       this.formatExprValue(ctx, expr);
     return stmt;
@@ -449,7 +449,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!orderBy)
       return stmt;
-    stmt.newline().raw("ORDER BY").space();
+    stmt.addLine("ORDER BY").space();
     for (const { expr, order } of stmt.separate(orderBy)) {
       this.formatExprValue(ctx, expr);
       stmt.add(order === OrderDirection.Asc ? "ASC" : "DESC");
@@ -460,7 +460,7 @@ class Formatter {
     const { stmt, forceInline } = ctx;
     if (!limit && !offset && !singleResult)
       return stmt;
-    stmt.newline().raw("LIMIT").space();
+    stmt.addLine("LIMIT").space();
     this.formatValue(ctx, singleResult ? 1 : limit);
     if (offset && offset > 0) {
       stmt.add("OFFSET").space();
@@ -678,7 +678,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!ctx.formatAsJson) {
       stmt.openParenthesis();
-      this.format(ctx, expr.query);
+      this.format({ ...ctx, formatAsIn: false }, expr.query);
       return stmt.closeParenthesis();
     }
     if (expr.query.singleResult) {

package/dist/lib/SqlError.d.ts

@@ -1,3 +1,3 @@
 export declare class SqlError extends Error {
-    constructor(cause: Error, sql: string);
+    constructor(cause: unknown, sql: string);
 }

package/dist/lib/Statement.d.ts

@@ -1,8 +1,15 @@
 import { ParamData } from '../define/Param.js';
 import { Sanitizer } from './Sanitizer.js';
 export interface StatementOptions {
+    /**
+     * Do not add any newlines while composing the statement
+     */
     skipNewlines?: boolean;
 }
+/**
+ * A statement is a query string builder with parameter placeholders, and a list
+ * of parameter values.
+ */
 export declare class Statement {
     sanitizer: Sanitizer;
     options: StatementOptions;
@@ -10,24 +17,92 @@ export declare class Statement {
     paramData: Array<ParamData>;
     currentIndent: string;
     constructor(sanitizer: Sanitizer, options?: StatementOptions);
-    space(): this;
+    /**
+     * UNSAFE
+     * Adds a string without applying escaping
+     */
+    raw(query: string): this;
+    /**
+     * UNSAFE
+     * Adds a space if the statement is not empty, and then adds the given string
+     * without applying escaping
+     */
     add(addition: undefined | string): this;
+    /**
+     * UNSAFE
+     * Adds a newline if the statement is not empty, and then adds the given
+     * string without applying escaping
+     */
     addLine(addition: undefined | string): this;
+    /**
+     * Adds a space if the statement is not empty
+     */
+    space(): this;
+    /**
+     * Increases the indentation level
+     */
     indent(): this;
+    /**
+     * Decreases the indentation level
+     */
     dedent(): this;
+    /**
+     * Adds a newline
+     */
     newline(): this;
+    /**
+     * Adds an identifier, applies escaping
+     */
     identifier(name: string): this;
+    /**
+     * Adds a space if the statement is not empty, and then adds an identifier
+     */
     addIdentifier(name: string): this;
+    /**
+     * Adds a value, applies escaping
+     */
     value(value: any): this;
+    /**
+     * Adds a space if the statement is not empty, and then adds a value
+     */
     addValue(value: any): this;
+    /**
+     * Adds a parameter
+     */
     param(data: ParamData): this;
+    /**
+     * Adds a space if the statement is not empty, and then adds a parameter
+     */
     addParam(data: ParamData): this;
-    raw(query: string): this;
+    /**
+     * Opens a parenthesis and indents the next line
+     */
     openParenthesis(): this;
+    /**
+     * Closes a parenthesis and dedents the next line
+     */
     closeParenthesis(): this;
+    /**
+     * Adds parenthesis on start and end, and a seperator to the output on
+     * each iteration
+     */
     call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
+    /**
+     * Adds seperator to the output on each iteration
+     */
     separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    /**
+     * Returns true if the statement is empty
+     */
     isEmpty(): boolean;
+    /**
+     * Returns the parameter values in the order they appear in the query string
+     */
     params(input?: Record<string, any>): Array<any>;
+    /**
+     * For debug purposes this will apply parameter values to the query string,
+     * and return the result
+     */
+    inlineParams(): string;
     toString(): string;
 }

package/dist/lib/Statement.js

@@ -11,66 +11,120 @@ class Statement {
   sql = "";
   paramData = [];
   currentIndent = "";
-  space() {
-    if (this.sql === "")
+  /**
+   * UNSAFE
+   * Adds a string without applying escaping
+   */
+  raw(query) {
+    if (!query)
       return this;
-    return this.raw(WHITESPACE);
+    this.sql += query;
+    return this;
   }
+  /**
+   * UNSAFE
+   * Adds a space if the statement is not empty, and then adds the given string
+   * without applying escaping
+   */
   add(addition) {
     if (!addition)
       return this;
     return this.space().raw(addition);
   }
+  /**
+   * UNSAFE
+   * Adds a newline if the statement is not empty, and then adds the given
+   * string without applying escaping
+   */
   addLine(addition) {
     if (!addition)
       return this;
     return this.newline().raw(addition);
   }
+  /**
+   * Adds a space if the statement is not empty
+   */
+  space() {
+    if (this.sql === "")
+      return this;
+    return this.raw(WHITESPACE);
+  }
+  /**
+   * Increases the indentation level
+   */
   indent() {
     this.currentIndent = this.currentIndent + "  ";
     return this;
   }
+  /**
+   * Decreases the indentation level
+   */
   dedent() {
     this.currentIndent = this.currentIndent.slice(0, -2);
     return this;
   }
+  /**
+   * Adds a newline
+   */
   newline() {
     if (this.options.skipNewlines)
       return this;
     return this.raw(NEWLINE + this.currentIndent);
   }
+  /**
+   * Adds an identifier, applies escaping
+   */
   identifier(name) {
     return this.raw(this.sanitizer.escapeIdentifier(name));
   }
+  /**
+   * Adds a space if the statement is not empty, and then adds an identifier
+   */
   addIdentifier(name) {
     return this.space().identifier(name);
   }
+  /**
+   * Adds a value, applies escaping
+   */
   value(value) {
     this.paramData.push(new ParamData.Value(value));
     return this.raw(INSERT_PARAM);
   }
+  /**
+   * Adds a space if the statement is not empty, and then adds a value
+   */
   addValue(value) {
     return this.space().value(value);
   }
+  /**
+   * Adds a parameter
+   */
   param(data) {
     this.paramData.push(data);
     return this.raw(INSERT_PARAM);
   }
+  /**
+   * Adds a space if the statement is not empty, and then adds a parameter
+   */
   addParam(data) {
     return this.space().param(data);
   }
-  raw(query) {
-    if (!query)
-      return this;
-    this.sql += query;
-    return this;
-  }
+  /**
+   * Opens a parenthesis and indents the next line
+   */
   openParenthesis() {
     return this.raw("(").indent().newline();
   }
+  /**
+   * Closes a parenthesis and dedents the next line
+   */
   closeParenthesis() {
     return this.dedent().newline().raw(")");
   }
+  /**
+   * Adds parenthesis on start and end, and a seperator to the output on
+   * each iteration
+   */
   *call(parts, separator = SEPARATE) {
     if (parts.length === 0)
       return this.raw("()");
@@ -78,6 +132,9 @@ class Statement {
     yield* this.separate(parts, separator);
     this.closeParenthesis();
   }
+  /**
+   * Adds seperator to the output on each iteration
+   */
   *separate(parts, separator = SEPARATE) {
     for (let i = 0; i < parts.length; i++) {
       if (i > 0)
@@ -85,9 +142,15 @@ class Statement {
       yield parts[i];
     }
   }
+  /**
+   * Returns true if the statement is empty
+   */
   isEmpty() {
     return this.sql === "";
   }
+  /**
+   * Returns the parameter values in the order they appear in the query string
+   */
   params(input) {
     return this.paramData.map((param) => {
       if (param.type === ParamType.Named) {
@@ -98,6 +161,20 @@ class Statement {
       return this.sanitizer.formatParamValue(param.value);
     });
   }
+  /**
+   * For debug purposes this will apply parameter values to the query string,
+   * and return the result
+   */
+  inlineParams() {
+    let index = 0;
+    return this.sql.replace(/\?/g, () => {
+      const param = this.paramData[index];
+      index++;
+      if (param.type === ParamType.Named)
+        throw new TypeError(`Missing parameter ${param.name}`);
+      return this.sanitizer.escapeValue(param.value);
+    });
+  }
   toString() {
     return this.sql;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.36",
+  "version": "0.2.39",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,7 +59,7 @@
     "sade": "^1.8.1",
     "speedscope": "^1.15.0",
     "sql.js": "^1.8.0",
-    "sqlite3": "^5.1.4",
+    "sqlite3": "^5.1.6",
     "tsx": "^3.12.3",
     "typescript": "beta",
     "uvu": "^0.5.6"