rado 0.1.23 → 0.1.25

package/dist/lib/Cursor.d.ts

@@ -1,77 +1,78 @@
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
-export declare class Cursor<T> {
-    [Selection.__cursorType](): T;
-    constructor(query: Query<T>);
-    query(): Query<T>;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Limitable<T> extends Cursor<T> {
-        take(limit: number | undefined): Limitable<T>;
-        skip(offset: number | undefined): Limitable<T>;
-    }
-    class Filterable<T> extends Limitable<T> {
-        where(...where: Array<EV<boolean>>): Filterable<T>;
-    }
-    class Delete<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-    }
-    class Update<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query: () => Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class InsertValues extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Insert;
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
-    }
-    class Create extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        constructor(queries: Array<Query>);
-    }
-    class SelectMultiple<T> extends Filterable<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Filterable<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        all(): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-}
+import { EV, Expr } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Query } from './Query';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Table } from './Table';
+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>;
+}
+export declare namespace Cursor {
+    class Limitable<T> extends Cursor<T> {
+        take(limit: number | undefined): Limitable<T>;
+        skip(offset: number | undefined): Limitable<T>;
+    }
+    class Filterable<T> extends Limitable<T> {
+        where(...where: Array<EV<boolean>>): Filterable<T>;
+    }
+    class Delete extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+    }
+    class Update<T> extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query: () => Query.Update;
+        set(set: UpdateSet<T>): Update<T>;
+    }
+    class InsertValuesReturning<T> extends Cursor<T> {
+    }
+    class InsertValues extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Insert;
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    class Insert<T> {
+        protected into: Schema;
+        constructor(into: Schema);
+        values(...data: Array<Table.Insert<T>>): InsertValues;
+    }
+    class Create extends Cursor<void> {
+        protected table: Schema;
+        constructor(table: Schema);
+    }
+    class Batch<T = void> extends Cursor<T> {
+        protected queries: Array<Query>;
+        constructor(queries: Array<Query>);
+    }
+    class SelectMultiple<T> extends Filterable<Array<T>> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+        count(): SelectSingle<number>;
+        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
+        first(): SelectSingle<T | undefined>;
+        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+    class SelectSingle<T> extends Filterable<T> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
+        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        all(): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+}

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,89 +1,105 @@
-import { Cursor } from './Cursor';
-import { Formatter } from './Formatter';
-import { Query } from './Query';
-import { SchemaInstructions } from './Schema';
-import { Statement } from './Statement';
-import { Table } from './Table';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    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;
-}
-interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
-    (strings: TemplateStringsArray, ...values: any[]): any;
-}
-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 schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): Array<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
-    get<T>(cursor: Cursor<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    transaction<T>(run: (query: SyncDriver) => T): T;
-    toAsync(): SyncWrapper;
-}
-interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
-    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-}
-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 schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-    executeQuery<T>(query: Query<T>): 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>>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Cursor<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
-}
-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;
-    }>;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-}
-export declare namespace Driver {
-    type Sync = SyncDriver;
-    const Sync: typeof SyncDriver;
-    type Async = AsyncDriver;
-    const Async: typeof AsyncDriver;
-}
-export {};
+import { Cursor } from './Cursor';
+import { Expr } from './Expr';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+import { SchemaInstructions } from './Schema';
+import { CompiledStatement } from './Statement';
+import { Table } from './Table';
+declare class Callable extends Function {
+    constructor(fn: 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;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: 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>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
+    all<T>(cursor: Cursor.SelectSingle<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;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    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>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    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>, 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>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    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);