rado 0.2.40 → 0.2.42

package/dist/define/Expr.d.ts

@@ -170,7 +170,7 @@ export declare namespace Expr {
     const IsExpr: unique symbol;
     const ToExpr: unique symbol;
     const NULL: Expr<null>;
-    function value<T>(value: T): Expr<T>;
+    function value<T>(value: T, inline?: boolean): Expr<T>;
     function get<T = any>(expr: ObjectExpr, field: string): Expr<T>;
     function create<T>(input: EV<T>): Expr<T>;
     function and(...conditions: Array<EV<boolean>>): Expr<boolean>;

package/dist/define/Expr.js

@@ -392,8 +392,8 @@ class Expr {
   Expr2.IsExpr = Symbol("Expr.IsExpr");
   Expr2.ToExpr = Symbol("Expr.ToExpr");
   Expr2.NULL = create(null);
-  function value(value2) {
-    return new Expr2(new ExprData.Param(new ParamData.Value(value2)));
+  function value(value2, inline = false) {
+    return new Expr2(new ExprData.Param(new ParamData.Value(value2, inline)));
   }
   Expr2.value = value;
   function get(expr, field) {

package/dist/define/Param.d.ts

@@ -5,8 +5,9 @@ export declare enum ParamType {
 export declare namespace ParamData {
     class Value {
         value: any;
+        inline: boolean;
         type: ParamType.Value;
-        constructor(value: any);
+        constructor(value: any, inline?: boolean);
     }
     class Named {
         name: string;

package/dist/define/Param.js

@@ -6,8 +6,9 @@ var ParamType = /* @__PURE__ */ ((ParamType2) => {
 var ParamData;
 ((ParamData2) => {
   class Value {
-    constructor(value) {
+    constructor(value, inline = false) {
       this.value = value;
+      this.inline = inline;
     }
     type = "ParamData.Value" /* Value */;
   }

package/dist/define/Sql.d.ts

@@ -1,6 +1,6 @@
 import { Query } from './Query.js';
 export declare function sql<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
 export declare namespace sql {
-    function all<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
-    function get<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
+    function all<T = unknown>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<Array<T>>;
+    function get<T = unknown>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
 }

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;
@@ -77,7 +75,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
     formatString(ctx: FormatContext, input: string): Statement;
     formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
-    formatValue(ctx: FormatContext, rawValue: any): Statement;
+    formatValue(ctx: FormatContext, rawValue: any, inline?: boolean): Statement;
     formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
     formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
     formatExpr(ctx: FormatContext, expr: ExprData): Statement;
@@ -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

@@ -502,8 +502,9 @@ class Formatter {
         return this.formatString(ctx, JSON.stringify(rawValue));
     }
   }
-  formatValue(ctx, rawValue) {
+  formatValue(ctx, rawValue, inline = false) {
     const { stmt, formatAsJson, formatAsInsert, forceInline } = ctx;
+    const inlineValue = inline || forceInline;
     const asJson = formatAsJson || formatAsInsert;
     switch (true) {
       case (rawValue === null || rawValue === void 0):
@@ -519,7 +520,7 @@ class Formatter {
         stmt.closeParenthesis();
         return stmt;
       case (typeof rawValue === "string" || typeof rawValue === "number"):
-        if (forceInline)
+        if (inlineValue)
           return stmt.raw(this.escapeValue(rawValue));
         return stmt.value(rawValue);
       default:
@@ -527,7 +528,7 @@ class Formatter {
           stmt.raw("json");
           stmt.openParenthesis();
         }
-        if (forceInline)
+        if (inlineValue)
           this.formatString(ctx, JSON.stringify(rawValue));
         else
           stmt.value(JSON.stringify(rawValue));
@@ -584,14 +585,17 @@ 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) {
     const { stmt } = ctx;
     switch (expr.param.type) {
       case ParamType.Value:
-        return this.formatValue(ctx, expr.param.value);
+        return this.formatValue(ctx, expr.param.value, expr.param.inline);
       case ParamType.Named:
         return stmt.param(expr.param);
     }
@@ -606,6 +610,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 +689,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 +722,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 +791,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 +804,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/package.json

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