rado 0.1.34 → 0.1.36

package/dist/lib/Cursor.d.ts

@@ -1,3 +1,4 @@
+import { Driver } from './Driver';
 import { EV, Expr } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Query } from './Query';
@@ -10,26 +11,27 @@ export declare class Cursor<T> {
     constructor(query: Query<T>);
     static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
     query(): Query<T>;
+    run(driver: Driver.Sync): T;
+    run(driver: Driver.Async): Promise<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<{
+    class Delete extends Cursor<{
         rowsAffected: number;
     }> {
         query(): Query.Delete;
+        where(...where: Array<EV<boolean>>): Delete;
+        take(limit: number | undefined): Delete;
+        skip(offset: number | undefined): Delete;
     }
-    class Update<T> extends Filterable<{
+    class Update<T> extends Cursor<{
         rowsAffected: number;
     }> {
         query: () => Query.Update;
         set(set: UpdateSet<T>): Update<T>;
+        where(...where: Array<EV<boolean>>): Update<T>;
+        take(limit: number | undefined): Update<T>;
+        skip(offset: number | undefined): Update<T>;
     }
     class InsertValuesReturning<T> extends Cursor<T> {
     }
@@ -44,7 +46,7 @@ export declare namespace Cursor {
         constructor(into: Schema);
         values(...data: Array<Table.Insert<T>>): InsertValues;
     }
-    class Create extends Cursor<void> {
+    class CreateTable extends Cursor<void> {
         protected table: Schema;
         constructor(table: Schema);
     }
@@ -52,7 +54,7 @@ export declare namespace Cursor {
         protected queries: Array<Query>;
         constructor(queries: Array<Query>);
     }
-    class SelectMultiple<T> extends Filterable<Array<T>> {
+    class SelectMultiple<T> extends Cursor<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>;
@@ -63,9 +65,11 @@ export declare namespace Cursor {
         first(): SelectSingle<T | undefined>;
         sure(): SelectSingle<T>;
         where(...where: Array<EV<boolean>>): SelectMultiple<T>;
+        take(limit: number | undefined): SelectMultiple<T>;
+        skip(offset: number | undefined): SelectMultiple<T>;
         toExpr(): Expr<T>;
     }
-    class SelectSingle<T> extends Filterable<T> {
+    class SelectSingle<T> extends Cursor<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>;
@@ -73,6 +77,8 @@ export declare namespace Cursor {
         orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
         groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
         where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        take(limit: number | undefined): SelectSingle<T>;
+        skip(offset: number | undefined): SelectSingle<T>;
         all(): SelectMultiple<T>;
         toExpr(): Expr<T>;
     }

package/dist/lib/Cursor.js

@@ -21,41 +21,51 @@ var Cursor = class {
   query() {
     throw new Error("Not implemented");
   }
+  run(driver) {
+    return driver.executeQuery(this.query());
+  }
   toJSON() {
     return this.query();
   }
 };
+function addWhere(query, where) {
+  const conditions = where.slice();
+  if (query.where)
+    conditions.push(query.where);
+  return {
+    ...query,
+    where: Expr.and(...conditions).expr
+  };
+}
 ((Cursor2) => {
-  class Limitable extends Cursor2 {
-    take(limit) {
-      return new Limitable({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new Limitable({ ...this.query(), offset });
+  class Delete extends Cursor2 {
+    query() {
+      return super.query();
     }
-  }
-  Cursor2.Limitable = Limitable;
-  class Filterable extends Limitable {
     where(...where) {
-      const condition = Expr.and(...where);
-      const query = this.query();
-      return new Filterable({
-        ...query,
-        where: (query.where ? condition.and(new Expr(query.where)) : condition).expr
-      });
+      return new Delete(addWhere(this.query(), where));
     }
-  }
-  Cursor2.Filterable = Filterable;
-  class Delete extends Filterable {
-    query() {
-      return super.query();
+    take(limit) {
+      return new Delete({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Delete({ ...this.query(), offset });
     }
   }
   Cursor2.Delete = Delete;
-  class Update extends Filterable {
+  class Update extends Cursor2 {
     set(set) {
       return new Update({ ...this.query(), set });
     }
+    where(...where) {
+      return new Update(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new Update({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Update({ ...this.query(), offset });
+    }
   }
   Cursor2.Update = Update;
   class InsertValuesReturning extends Cursor2 {
@@ -81,13 +91,13 @@ var Cursor = class {
     }
   }
   Cursor2.Insert = Insert;
-  class Create extends Cursor2 {
+  class CreateTable extends Cursor2 {
     constructor(table) {
       super(Schema.create(table));
       this.table = table;
     }
   }
-  Cursor2.Create = Create;
+  Cursor2.CreateTable = CreateTable;
   class Batch extends Cursor2 {
     constructor(queries) {
       super(Query.Batch({ queries }));
@@ -95,7 +105,7 @@ var Cursor = class {
     }
   }
   Cursor2.Batch = Batch;
-  class SelectMultiple extends Filterable {
+  class SelectMultiple extends Cursor2 {
     query() {
       return super.query();
     }
@@ -161,14 +171,20 @@ var Cursor = class {
       });
     }
     where(...where) {
-      return new SelectMultiple(super.where(...where).query());
+      return new SelectMultiple(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectMultiple({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectMultiple({ ...this.query(), offset });
     }
     toExpr() {
       return new Expr(ExprData.Query(this.query()));
     }
   }
   Cursor2.SelectMultiple = SelectMultiple;
-  class SelectSingle extends Filterable {
+  class SelectSingle extends Cursor2 {
     query() {
       return super.query();
     }
@@ -215,7 +231,13 @@ var Cursor = class {
       });
     }
     where(...where) {
-      return new SelectSingle(super.where(...where).query());
+      return new SelectSingle(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectSingle({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectSingle({ ...this.query(), offset });
     }
     all() {
       return new SelectMultiple({ ...this.query(), singleResult: false });

package/dist/lib/Driver.d.ts

@@ -90,6 +90,7 @@ interface AsyncPreparedStatement {
     get<T>(params?: Array<any>): Promise<T>;
     execute(params?: Array<any>): Promise<void>;
 }
+export type Driver = SyncDriver | AsyncDriver;
 export declare namespace Driver {
     type Sync = SyncDriver;
     const Sync: typeof SyncDriver;

package/dist/lib/Expr.js

@@ -242,7 +242,7 @@ var _Expr = class {
   }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
+    const target = Target.Expr(this.expr, alias);
     return new _Expr(
       ExprData.Filter(
         target,
@@ -252,7 +252,7 @@ var _Expr = class {
   }
   map(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
+    const target = Target.Expr(this.expr, alias);
     return new _Expr(
       ExprData.Map(
         target,

package/dist/lib/Formatter.js

@@ -316,7 +316,7 @@ var Formatter = class {
       case TargetType.Table:
         stmt.identifier(target.table.name);
         if (target.table.alias)
-          stmt.add("AS").addIdentifier(target.table.alias);
+          stmt.raw("AS").addIdentifier(target.table.alias);
         return stmt;
       case TargetType.Join:
         const { left, right, joinType } = target;
@@ -326,8 +326,15 @@ var Formatter = class {
         stmt.add("ON");
         this.formatExprValue(ctx, target.on);
         return stmt;
-      default:
-        throw new Error(`Cannot format target of type ${target.type}`);
+      case TargetType.Query:
+        stmt.openParenthesis();
+        this.format(ctx, target.query);
+        stmt.closeParenthesis();
+        if (target.alias)
+          stmt.raw("AS").addIdentifier(target.alias);
+        return stmt;
+      case TargetType.Expr:
+        throw new Error("Cannot format expression as target");
     }
   }
   formatWhere(ctx, expr) {
@@ -541,10 +548,10 @@ var Formatter = class {
           stmt.raw("exists").space();
           return this.formatExprValue(ctx, expr.params[0]);
         } else {
-          stmt.addIdentifier(expr.method).openParenthesis();
-          for (const param of stmt.separate(expr.params))
+          stmt.identifier(expr.method);
+          for (const param of stmt.call(expr.params))
             this.formatExprValue(ctx, param);
-          return stmt.closeParenthesis();
+          return stmt;
         }
       }
       case ExprType.Query:
@@ -578,7 +585,8 @@ var Formatter = class {
                 )
               )
             );
-          case TargetType.Each:
+          case TargetType.Query:
+          case TargetType.Expr:
             return stmt.identifier(expr.target.alias).raw(".value");
           default:
             throw new Error(`Cannot select from ${expr.target.type}`);
@@ -599,10 +607,13 @@ var Formatter = class {
       case ExprType.Filter: {
         const { target, condition } = expr;
         switch (target.type) {
-          case TargetType.Each:
+          case TargetType.Expr:
             stmt.openParenthesis().raw("SELECT json_group_array(json(result)) FROM ").openParenthesis().raw("SELECT value AS result").add("FROM json_each").openParenthesis();
-            this.formatExpr(ctx, target.expr);
-            stmt.closeParenthesis().add("AS").addIdentifier(target.alias).add("WHERE").space();
+            this.formatExprJson(ctx, target.expr);
+            stmt.closeParenthesis();
+            if (target.alias)
+              stmt.add("AS").addIdentifier(target.alias);
+            stmt.add("WHERE").space();
             this.formatExprValue(ctx, condition);
             return stmt.closeParenthesis().closeParenthesis();
           default:
@@ -612,11 +623,14 @@ var Formatter = class {
       case ExprType.Map: {
         const { target, result } = expr;
         switch (target.type) {
-          case TargetType.Each:
+          case TargetType.Expr:
             stmt.openParenthesis().raw("SELECT json_group_array(json(result)) FROM ").openParenthesis().raw("SELECT").space();
             this.formatExprJson(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
             this.formatExprJson(ctx, target.expr);
-            return stmt.closeParenthesis().add("AS").addIdentifier(target.alias).closeParenthesis().closeParenthesis();
+            stmt.closeParenthesis();
+            if (target.alias)
+              stmt.add("AS").addIdentifier(target.alias);
+            return stmt.closeParenthesis().closeParenthesis();
           default:
             throw new Error("todo");
         }

package/dist/lib/Ops.d.ts

@@ -1,7 +1,6 @@
 import { Cursor } from './Cursor';
 import { Table } from './Table';
-export declare function selectAll<Row>(table: Table<Row>): Cursor.SelectMultiple<Row>;
-export declare function selectFirst<Row>(table: Table<Row>): Cursor.SelectSingle<Row>;
+export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<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;

package/dist/lib/Ops.js

@@ -4,20 +4,12 @@ import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
-function selectAll(table) {
+function from(source) {
+  const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
   return new Cursor.SelectMultiple(
     Query.Select({
-      from: Target.Table(table.schema()),
-      selection: ExprData.Row(Target.Table(table.schema()))
-    })
-  );
-}
-function selectFirst(table) {
-  return new Cursor.SelectSingle(
-    Query.Select({
-      from: Target.Table(table.schema()),
-      selection: ExprData.Row(Target.Table(table.schema())),
-      singleResult: true
+      from: target,
+      selection: ExprData.Row(target)
     })
   );
 }
@@ -38,8 +30,7 @@ function create(...tables) {
 export {
   create,
   deleteFrom,
+  from,
   insertInto,
-  selectAll,
-  selectFirst,
   update
 };

package/dist/lib/Statement.d.ts

@@ -43,7 +43,7 @@ export declare class Statement {
     raw(query: string): this;
     openParenthesis(): this;
     closeParenthesis(): this;
-    call<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
     separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
     isEmpty(): boolean;
     compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;

package/dist/lib/Statement.js

@@ -99,6 +99,8 @@ var Statement = class {
     return this.dedent().newline().raw(")");
   }
   *call(parts, separator = SEPARATE) {
+    if (parts.length === 0)
+      return this.raw("()");
     this.openParenthesis();
     yield* this.separate(parts, separator);
     this.closeParenthesis();

package/dist/lib/Table.d.ts

@@ -16,7 +16,7 @@ export declare class Table<T> extends Cursor.SelectMultiple<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;
+    createTable(): Cursor.CreateTable;
     as(alias: string): this;
     alias(): Record<string, this>;
     get(name: string): Expr<any>;

package/dist/lib/Table.js

@@ -59,7 +59,7 @@ var Table = class extends Cursor.SelectMultiple {
     return new Cursor.Delete(Query.Delete({ table: this.schema() }));
   }
   createTable() {
-    return new Cursor.Create(this.schema());
+    return new Cursor.CreateTable(this.schema());
   }
   as(alias) {
     return new Table({ ...this.schema(), alias });

package/dist/lib/Target.d.ts

@@ -1,18 +1,26 @@
 import { ExprData } from './Expr';
+import { Query as QueryData } from './Query';
 import { Schema } from './Schema';
 export declare enum TargetType {
-    Each = "Each",
+    Expr = "Expr",
+    Query = "Query",
     Table = "Table",
     Join = "Join"
 }
-export type Target = Target.Each | Target.Table | Target.Join;
+export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
 export declare namespace Target {
-    interface Each {
-        type: TargetType.Each;
+    interface Expr {
+        type: TargetType.Expr;
         expr: ExprData;
-        alias: string;
+        alias?: string;
     }
-    function Each(expr: ExprData, alias: string): Each;
+    function Expr(expr: ExprData, alias?: string): Expr;
+    interface Query {
+        type: TargetType.Query;
+        query: QueryData;
+        alias?: string;
+    }
+    function Query(query: QueryData, alias?: string): Query;
     interface Table {
         type: TargetType.Table;
         table: Schema;

package/dist/lib/Target.js

@@ -1,16 +1,21 @@
 // src/lib/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
-  TargetType2["Each"] = "Each";
+  TargetType2["Expr"] = "Expr";
+  TargetType2["Query"] = "Query";
   TargetType2["Table"] = "Table";
   TargetType2["Join"] = "Join";
   return TargetType2;
 })(TargetType || {});
 var Target;
 ((Target2) => {
-  function Each(expr, alias) {
-    return { type: "Each" /* Each */, expr, alias };
+  function Expr(expr, alias) {
+    return { type: "Expr" /* Expr */, expr, alias };
   }
-  Target2.Each = Each;
+  Target2.Expr = Expr;
+  function Query(query, alias) {
+    return { type: "Query" /* Query */, query, alias };
+  }
+  Target2.Query = Query;
   function Table(table) {
     return { type: "Table" /* Table */, table };
   }

package/package.json

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