rado 0.1.33 → 0.1.35

package/dist/lib/Expr.d.ts

@@ -125,8 +125,8 @@ export declare class Expr<T> {
     isNotNull(): Expr<boolean>;
     isNot(that: EV<T>): Expr<boolean>;
     is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
-    isIn(that: EV<Array<T>> | Cursor<T>): Expr<boolean>;
-    isNotIn(that: EV<Array<T>> | Cursor<T>): Expr<boolean>;
+    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
     add(this: Expr<number>, that: EV<number>): Expr<number>;
     substract(this: Expr<number>, that: EV<number>): Expr<number>;
     multiply(this: Expr<number>, that: EV<number>): Expr<number>;

package/dist/lib/Expr.js

@@ -187,10 +187,10 @@ var _Expr = class {
       return this.isNull();
     return binop(this, "Equals" /* Equals */, that);
   }
-  isIn(that) {
+  in(that) {
     return binop(this, "In" /* In */, that);
   }
-  isNotIn(that) {
+  notIn(that) {
     return binop(this, "NotIn" /* NotIn */, that);
   }
   add(that) {
@@ -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/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.33",
+  "version": "0.1.35",
   "license": "MIT",
   "type": "module",
   "exports": {