rado 0.1.23 → 0.1.25

package/README.md

@@ -1 +1 @@
-# rado
+# rado

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

@@ -1,17 +1,15 @@
-import type { Database } from 'better-sqlite3';
-import { Driver } from '../lib/Driver';
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare class BetterSqlite3Driver extends Driver.Sync {
-    db: Database;
-    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;
-    };
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): BetterSqlite3Driver;
+import type { Database } from 'better-sqlite3';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+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);
+    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): BetterSqlite3Driver;

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,17 +1,15 @@
-import type { Database } from 'sql.js';
-import { Driver } from '../lib/Driver';
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare class SqlJsDriver extends Driver.Sync {
-    db: Database;
-    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;
-    };
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): SqlJsDriver;
+import type { Database } from 'sql.js';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+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);
+    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): SqlJsDriver;

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

@@ -1,20 +1,18 @@
-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';
-export declare class Sqlite3Driver extends Driver.Async {
-    private db;
-    lock: Promise<void> | undefined;
-    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;
-    }>;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
-}
-export declare function connect(db: Database): Sqlite3Driver;
+import type { Database } from 'sqlite3';
+import { Driver } from '../lib/Driver';
+import { Query } from '../lib/Query';
+import { SchemaInstructions } from '../lib/Schema';
+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>, 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>];
+}
+export declare function connect(db: Database): Sqlite3Driver;

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/index.d.ts

@@ -1,20 +1,20 @@
-export * from './lib/Column';
-export * from './lib/Cursor';
-export * from './lib/Driver';
-export * from './lib/Expr';
-export * from './lib/Fields';
-export * from './lib/Formatter';
-export * from './lib/Functions';
-export * from './lib/Id';
-export * from './lib/Index';
-export * from './lib/Ops';
-export * from './lib/OrderBy';
-export * from './lib/Param';
-export * from './lib/Query';
-export * from './lib/Sanitizer';
-export * from './lib/Schema';
-export * from './lib/Selection';
-export * from './lib/Statement';
-export * from './lib/Table';
-export * from './lib/Target';
-export * from './lib/Update';
+export * from './lib/Column';
+export * from './lib/Cursor';
+export * from './lib/Driver';
+export * from './lib/Expr';
+export * from './lib/Fields';
+export * from './lib/Formatter';
+export * from './lib/Functions';
+export * from './lib/Id';
+export * from './lib/Index';
+export * from './lib/Ops';
+export * from './lib/OrderBy';
+export * from './lib/Param';
+export * from './lib/Query';
+export * from './lib/Sanitizer';
+export * from './lib/Schema';
+export * from './lib/Selection';
+export * from './lib/Statement';
+export * from './lib/Table';
+export * from './lib/Target';
+export * from './lib/Update';

package/dist/lib/Column.d.ts

@@ -1,57 +1,57 @@
-import { EV, Expr, ExprData } from './Expr';
-export declare enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-interface PartialColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: ExprData;
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-    references?: ExprData;
-}
-export interface ColumnData extends PartialColumnData {
-    type: ColumnType;
-    name: string;
-}
-export declare class Column<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.IsOptional<T>>;
-    primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X>): Column<X>;
-    unique(): Column<T>;
-    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
-}
-export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
-};
-export declare namespace Column {
-    const isOptional: unique symbol;
-    type IsOptional<T> = {
-        [isOptional]: true;
-        __t: T;
-    };
-    const isPrimary: unique symbol;
-    type IsPrimary<T, K> = {
-        [isPrimary]: K;
-        __t: T;
-    };
-}
-export declare const column: {
-    string<T extends string = string>(): Column<T>;
-    integer<T_1 extends number = number>(): Column<T_1>;
-    number<T_2 extends number = number>(): Column<T_2>;
-    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
-    object<T_4 extends object = object>(): Column<T_4>;
-    array<T_5 = any>(): Column<T_5[]>;
-};
-export {};
+import { EV, Expr, ExprData } from './Expr';
+export declare enum ColumnType {
+    String = "String",
+    Integer = "Integer",
+    Number = "Number",
+    Boolean = "Boolean",
+    Json = "Json"
+}
+interface PartialColumnData {
+    type: ColumnType;
+    name?: string;
+    nullable?: boolean;
+    defaultValue?: ExprData;
+    autoIncrement?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    references?: ExprData;
+}
+export interface ColumnData extends PartialColumnData {
+    type: ColumnType;
+    name: string;
+}
+export declare class Column<T> {
+    data: PartialColumnData;
+    constructor(data: PartialColumnData);
+    name(name: string): Column<T>;
+    nullable(): Column<T | null>;
+    autoIncrement(): Column<Column.IsOptional<T>>;
+    primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
+    references<X extends T>(column: Expr<X>): Column<X>;
+    unique(): Column<T>;
+    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
+}
+export type PrimaryKey<T, K> = string extends K ? T : T & {
+    [Column.isPrimary]: K;
+};
+export declare namespace Column {
+    const isOptional: unique symbol;
+    type IsOptional<T> = {
+        [isOptional]: true;
+        __t: T;
+    };
+    const isPrimary: unique symbol;
+    type IsPrimary<T, K> = {
+        [isPrimary]: K;
+        __t: T;
+    };
+}
+export declare const column: {
+    string<T extends string = string>(): Column<T>;
+    integer<T_1 extends number = number>(): Column<T_1>;
+    number<T_2 extends number = number>(): Column<T_2>;
+    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
+    object<T_4 extends object = object>(): Column<T_4>;
+    array<T_5 = any>(): Column<T_5[]>;
+};
+export {};