rado 0.1.1 → 0.1.3

package/dist/Driver.d.ts

@@ -10,13 +10,15 @@ declare class Callable extends Function {
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
-    all(strings: TemplateStringsArray, ...params: Array<any>): any;
-    get(strings: TemplateStringsArray, ...params: Array<any>): any;
+    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 {
@@ -30,13 +32,17 @@ declare abstract class SyncDriver extends DriverBase {
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
     migrateSchema(...tables: Array<Table<any>>): unknown;
     executeQuery<T>(query: Query<T>): 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>>): T;
     (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
 }
 declare abstract class AsyncDriver extends DriverBase {
@@ -51,7 +57,10 @@ declare abstract class AsyncDriver extends DriverBase {
     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<T>): Promise<Array<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>;
 }

package/dist/Driver.js

@@ -12,25 +12,43 @@ var Callable = class extends Function {
     });
   }
 };
+function isTemplateStringsArray(input) {
+  return Boolean(Array.isArray(input) && input.raw);
+}
 var DriverBase = class extends Callable {
   constructor(formatter) {
     super((...args) => {
       const [input, ...rest] = args;
-      if (input instanceof Cursor)
+      if (input instanceof Cursor && rest.length === 0)
         return this.executeQuery(input.query());
-      return this.executeTemplate(void 0, input, ...rest);
+      if (isTemplateStringsArray(input))
+        return this.executeTemplate(void 0, input, ...rest);
+      return this.executeQuery(
+        Query.Batch({
+          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg.query())
+        })
+      );
     });
     this.formatter = formatter;
   }
-  all(strings, ...params) {
-    return this.executeTemplate("rows", strings, ...params);
+  all(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("rows", input, ...rest);
+  }
+  get(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor.SelectMultiple)
+      return this.executeQuery(input.first().query());
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("row", input, ...rest);
   }
-  get(strings, ...params) {
-    return this.executeTemplate("row", strings, ...params);
+  sql(strings, ...params) {
+    return new Cursor(Query.Raw({ strings, params }));
   }
   executeTemplate(expectedReturn, strings, ...params) {
-    if (strings.some((chunk) => chunk.includes("?")))
-      throw new TypeError("SQL injection hazard");
     return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
   }
 };
@@ -87,11 +105,11 @@ var SyncDriver = class extends DriverBase {
         }
     }
   }
-  all(strings, ...params) {
-    return super.all(strings, ...params);
+  all(...args) {
+    return super.all(...args);
   }
-  get(strings, ...params) {
-    return super.get(strings, ...params);
+  get(...args) {
+    return super.get(...args);
   }
   transaction(run) {
     const id = `t${this.transactionId++}`;
@@ -170,11 +188,11 @@ var AsyncDriver = class extends DriverBase {
         }
     }
   }
-  all(strings, ...params) {
-    return super.all(strings, ...params);
+  all(...args) {
+    return super.all(...args);
   }
-  get(strings, ...params) {
-    return super.get(strings, ...params);
+  get(...args) {
+    return super.get(...args);
   }
   async transaction(run) {
     const id = `t${this.transactionId++}`;

package/dist/Formatter.js

@@ -130,7 +130,7 @@ var Formatter = class {
     ).add(this.formatWhere(query.where, ctx));
   }
   formatDropIndex(query, ctx) {
-    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.index.name);
+    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.name);
   }
   formatAlterTable(query, ctx) {
     let stmt = raw("alter table").addIdentifier(query.table.name);

package/dist/Query.d.ts

@@ -68,7 +68,7 @@ export declare namespace Query {
     interface DropIndex extends QueryBase {
         type: QueryType.DropIndex;
         table: Schema;
-        index: Index;
+        name: string;
         ifExists?: boolean;
     }
     function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;

package/dist/Query.js

@@ -58,6 +58,8 @@ var Query;
   }
   Query2.Transaction = Transaction;
   function Raw(raw) {
+    if (raw.strings.some((chunk) => chunk.includes("?")))
+      throw new TypeError("SQL injection hazard");
     return { type: "Raw" /* Raw */, ...raw };
   }
   Query2.Raw = Raw;

package/dist/Schema.js

@@ -40,13 +40,13 @@ var Schema;
       if (!localInstruction) {
         res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
       } else if (!schemaIndex) {
-        res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+        res.push(Query.DropIndex({ table: schema, name: indexName }));
       } else {
         const [instruction] = formatter.formatCreateIndex(
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
         if (localInstruction !== instruction) {
-          res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+          res.push(Query.DropIndex({ table: schema, name: indexName }));
           res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
         }
       }

package/package.json

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