rado 0.2.39 → 0.2.41

package/dist/lib/Formatter.d.ts

@@ -20,7 +20,6 @@ export interface FormatContext {
     forceInline?: boolean;
     formatAsJson?: boolean;
     formatAsInsert?: boolean;
-    formatAsIn?: boolean;
     topLevel?: boolean;
     selectAsColumns?: boolean;
     formattingCte?: string;
@@ -43,7 +42,6 @@ export declare abstract class Formatter implements Sanitizer {
         forceInline?: boolean | undefined;
         formatAsJson?: boolean | undefined;
         formatAsInsert?: boolean | undefined;
-        formatAsIn?: boolean | undefined;
         topLevel?: boolean | undefined;
         selectAsColumns?: boolean | undefined;
         formattingCte?: string | undefined;
@@ -85,14 +83,24 @@ export declare abstract class Formatter implements Sanitizer {
     formatBinOp(ctx: FormatContext, expr: ExprData.BinOp): Statement;
     formatParam(ctx: FormatContext, expr: ExprData.Param): Statement;
     retrieveField(expr: ExprData, field: string): ExprData | undefined;
+    /**
+     * Format a in "{a}->>{b}"
+     */
+    formatExprAccess(ctx: FormatContext, expr: ExprData): Statement;
+    /**
+     * Format b in "{a} in {b}"
+     */
+    formatIn(ctx: FormatContext, expr: ExprData): Statement;
     formatFieldOf(ctx: FormatContext, from: ExprData, field: string): Statement;
-    formatField({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Field): Statement;
+    formatField(ctx: FormatContext, expr: ExprData.Field): Statement;
     formatCall(ctx: FormatContext, expr: ExprData.Call): Statement;
     formatQuery(ctx: FormatContext, expr: ExprData.Query): Statement;
     formatRow(ctx: FormatContext, expr: ExprData.Row): Statement;
     formatMerge(ctx: FormatContext, expr: ExprData.Merge): Statement;
     formatRecord(ctx: FormatContext, expr: ExprData.Record): Statement;
-    formatFilter({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Filter): Statement;
-    formatMap({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Map): Statement;
+    formatFilterIn(ctx: FormatContext, expr: ExprData.Filter): Statement;
+    formatFilter(ctx: FormatContext, expr: ExprData.Filter): Statement;
+    formatMapIn(ctx: FormatContext, expr: ExprData.Map): Statement;
+    formatMap(ctx: FormatContext, expr: ExprData.Map): Statement;
 }
 export {};

package/dist/lib/Formatter.js

@@ -440,7 +440,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!groupBy)
       return stmt;
-    stmt.addLine("GROUP BY");
+    stmt.addLine("GROUP BY").space();
     for (const expr of stmt.separate(groupBy))
       this.formatExprValue(ctx, expr);
     return stmt;
@@ -584,7 +584,10 @@ class Formatter {
     stmt.openParenthesis();
     this.formatExprValue(ctx, expr.a).add(binOps[expr.op]).space();
     const asIn = expr.op === BinOpType.In || expr.op === BinOpType.NotIn;
-    this.formatExprValue({ ...ctx, formatAsIn: asIn }, expr.b);
+    if (asIn)
+      this.formatIn(ctx, expr.b);
+    else
+      this.formatExprValue(ctx, expr.b);
     return stmt.closeParenthesis();
   }
   formatParam(ctx, expr) {
@@ -606,6 +609,51 @@ class Formatter {
         return void 0;
     }
   }
+  /**
+   * Format a in "{a}->>{b}"
+   */
+  formatExprAccess(ctx, expr) {
+    const { stmt } = ctx;
+    if (expr.type === ExprType.Field && expr.expr.type === ExprType.Row) {
+      const from = expr.expr;
+      switch (from.target.type) {
+        case TargetType.Table:
+          if (!ctx.skipTableName) {
+            stmt.identifier(from.target.table.alias || from.target.table.name).raw(".");
+          }
+          return stmt.identifier(expr.field);
+      }
+    }
+    return this.formatExpr(ctx, expr);
+  }
+  /**
+   * Format b in "{a} in {b}"
+   */
+  formatIn(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.type) {
+      case ExprType.Filter:
+        return this.formatFilterIn(ctx, expr);
+      case ExprType.Map:
+        return this.formatMapIn(ctx, expr);
+      case ExprType.Field:
+        stmt.openParenthesis();
+        stmt.raw("SELECT value FROM json_each");
+        stmt.openParenthesis();
+        this.formatExprValue(ctx, expr);
+        stmt.closeParenthesis();
+        return stmt.closeParenthesis();
+      case ExprType.Param:
+        if (expr.param.type === ParamType.Value && Array.isArray(expr.param.value)) {
+          stmt.openParenthesis();
+          for (const v of stmt.separate(expr.param.value))
+            this.formatValue(ctx, v);
+          return stmt.closeParenthesis();
+        }
+      default:
+        return this.formatExpr(ctx, expr);
+    }
+  }
   formatFieldOf(ctx, from, field) {
     const { stmt } = ctx;
     const fieldExpr = this.retrieveField(from, field);
@@ -640,19 +688,14 @@ class Formatter {
             return stmt;
         }
       default:
-        return this.formatAccess(ctx, () => this.formatExpr(ctx, from), field);
+        return this.formatAccess(
+          ctx,
+          () => this.formatExprAccess(ctx, from),
+          field
+        );
     }
   }
-  formatField({ formatAsIn, ...ctx }, expr) {
-    const { stmt } = ctx;
-    if (formatAsIn) {
-      stmt.openParenthesis();
-      stmt.raw("SELECT value FROM json_each");
-      stmt.openParenthesis();
-      this.formatExprJson(ctx, expr);
-      stmt.closeParenthesis();
-      return stmt.closeParenthesis();
-    }
+  formatField(ctx, expr) {
     return this.formatFieldOf(ctx, expr.expr, expr.field);
   }
   formatCall(ctx, expr) {
@@ -678,7 +721,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!ctx.formatAsJson) {
       stmt.openParenthesis();
-      this.format({ ...ctx, formatAsIn: false }, expr.query);
+      this.format(ctx, expr.query);
       return stmt.closeParenthesis();
     }
     if (expr.query.singleResult) {
@@ -747,15 +790,12 @@ class Formatter {
     }
     return stmt.closeParenthesis();
   }
-  formatFilter({ formatAsIn, ...ctx }, expr) {
+  formatFilterIn(ctx, expr) {
     const { stmt } = ctx;
     const { target, condition } = expr;
     switch (target.type) {
       case TargetType.Expr:
         stmt.openParenthesis();
-        if (!formatAsIn) {
-          stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
-        }
         stmt.raw("SELECT value AS result").add("FROM json_each").openParenthesis();
         this.formatExpr(ctx, target.expr);
         stmt.closeParenthesis();
@@ -763,37 +803,52 @@ class Formatter {
           stmt.add("AS").addIdentifier(target.alias);
         stmt.add("WHERE").space();
         this.formatExprValue(ctx, condition);
-        if (!formatAsIn) {
-          stmt.closeParenthesis();
-        }
         return stmt.closeParenthesis();
       default:
         throw new Error("todo");
     }
   }
-  formatMap({ formatAsIn, ...ctx }, expr) {
+  formatFilter(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.target.type) {
+      case TargetType.Expr:
+        stmt.openParenthesis().raw("SELECT json_group_array(json(result)) FROM ");
+        this.formatFilterIn(ctx, expr);
+        stmt.closeParenthesis();
+        return stmt;
+      default:
+        throw new Error("todo");
+    }
+  }
+  formatMapIn(ctx, expr) {
     const { stmt } = ctx;
     const { target, result } = expr;
     switch (target.type) {
       case TargetType.Expr:
         stmt.openParenthesis();
-        if (!formatAsIn) {
-          stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
-        }
         stmt.raw("SELECT").space();
         this.formatExpr(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
         this.formatExprJson(ctx, target.expr);
         stmt.closeParenthesis();
         if (target.alias)
           stmt.add("AS").addIdentifier(target.alias);
-        if (!formatAsIn) {
-          stmt.closeParenthesis();
-        }
         return stmt.closeParenthesis();
       default:
         throw new Error("todo");
     }
   }
+  formatMap(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.target.type) {
+      case TargetType.Expr:
+        stmt.openParenthesis().raw("SELECT json_group_array(json(result)) FROM ");
+        this.formatMapIn(ctx, expr);
+        stmt.closeParenthesis();
+        return stmt;
+      default:
+        throw new Error("todo");
+    }
+  }
 }
 export {
   Formatter

package/dist/lib/Statement.js

@@ -170,9 +170,12 @@ class Statement {
     return this.sql.replace(/\?/g, () => {
       const param = this.paramData[index];
       index++;
-      if (param.type === ParamType.Named)
-        throw new TypeError(`Missing parameter ${param.name}`);
-      return this.sanitizer.escapeValue(param.value);
+      switch (param.type) {
+        case ParamType.Named:
+          return `?${param.name}`;
+        case ParamType.Value:
+          return this.sanitizer.escapeValue(param.value);
+      }
     });
   }
   toString() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",