rado 0.1.59 → 0.1.61

package/dist/define/Cursor.d.ts

@@ -1,4 +1,5 @@
 import { Driver } from '../lib/Driver';
+import { CompileOptions } from '../lib/Formatter';
 import { EV, Expr } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Query } from './Query';
@@ -13,7 +14,7 @@ export declare class Cursor<T> {
     query(): Query<T>;
     on(driver: Driver.Sync): T;
     on(driver: Driver.Async): Promise<T>;
-    compile(driver: Driver): import("..").Statement;
+    compile(driver: Driver, options?: CompileOptions): import("..").Statement;
     toJSON(): Query<T>;
 }
 export declare namespace Cursor {

package/dist/define/Cursor.js

@@ -24,8 +24,8 @@ var Cursor = class {
   on(driver) {
     return driver.executeQuery(this.query());
   }
-  compile(driver) {
-    return driver.formatter.compile(this.query());
+  compile(driver, options) {
+    return driver.formatter.compile(this.query(), options);
   }
   toJSON() {
     return this.query();

package/dist/define/Expr.d.ts

@@ -5,11 +5,11 @@ import { ParamData } from './Param';
 import { Query } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
-export declare enum UnOp {
+export declare enum UnOpType {
     Not = "Not",
     IsNull = "IsNull"
 }
-export declare enum BinOp {
+export declare enum BinOpType {
     Add = "Add",
     Subt = "Subt",
     Mult = "Mult",
@@ -44,56 +44,74 @@ export declare enum ExprType {
     Merge = "Merge",
     Case = "Case"
 }
-export type ExprData = {
-    type: ExprType.UnOp;
-    op: UnOp;
-    expr: ExprData;
-} | {
-    type: ExprType.BinOp;
-    op: BinOp;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Field;
-    expr: ExprData;
-    field: string;
-} | {
-    type: ExprType.Param;
-    param: ParamData;
-} | {
-    type: ExprType.Call;
-    method: string;
-    params: Array<ExprData>;
-} | {
-    type: ExprType.Query;
-    query: Query.Select;
-} | {
-    type: ExprType.Record;
-    fields: Record<string, ExprData>;
-} | {
-    type: ExprType.Merge;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Row;
-    target: Target;
-} | {
-    type: ExprType.Map;
-    target: Target;
-    result: ExprData;
-} | {
-    type: ExprType.Filter;
-    target: Target;
-    condition: ExprData;
-} | {
-    type: ExprType.Case;
-    expr: ExprData;
-    cases: Record<string, ExprData>;
-    defaultCase?: ExprData;
-};
+export type ExprData = ExprData.UnOp | ExprData.BinOp | ExprData.Field | ExprData.Param | ExprData.Call | ExprData.Query | ExprData.Record | ExprData.Merge | ExprData.Row | ExprData.Map | ExprData.Filter | ExprData.Case;
+export declare namespace ExprData {
+    type UnOp = {
+        type: ExprType.UnOp;
+        op: UnOpType;
+        expr: ExprData;
+    };
+    type BinOp = {
+        type: ExprType.BinOp;
+        op: BinOpType;
+        a: ExprData;
+        b: ExprData;
+    };
+    type Field = {
+        type: ExprType.Field;
+        expr: ExprData;
+        field: string;
+    };
+    type Param = {
+        type: ExprType.Param;
+        param: ParamData;
+    };
+    type Call = {
+        type: ExprType.Call;
+        method: string;
+        params: Array<ExprData>;
+    };
+    type Query = {
+        type: ExprType.Query;
+        query: Query.Select;
+    };
+    type Record = {
+        type: ExprType.Record;
+        fields: {
+            [key: string]: ExprData;
+        };
+    };
+    type Merge = {
+        type: ExprType.Merge;
+        a: ExprData;
+        b: ExprData;
+    };
+    type Row = {
+        type: ExprType.Row;
+        target: Target;
+    };
+    type Map = {
+        type: ExprType.Map;
+        target: Target;
+        result: ExprData;
+    };
+    type Filter = {
+        type: ExprType.Filter;
+        target: Target;
+        condition: ExprData;
+    };
+    type Case = {
+        type: ExprType.Case;
+        expr: ExprData;
+        cases: {
+            [key: string]: ExprData;
+        };
+        defaultCase?: ExprData;
+    };
+}
 export declare const ExprData: {
-    UnOp(op: UnOp, expr: ExprData): ExprData;
-    BinOp(op: BinOp, a: ExprData, b: ExprData): ExprData;
+    UnOp(op: UnOpType, expr: ExprData): ExprData;
+    BinOp(op: BinOpType, a: ExprData, b: ExprData): ExprData;
     Field(expr: ExprData, field: string): ExprData;
     Param(param: ParamData): ExprData;
     Call(method: string, params: Array<ExprData>): ExprData;

package/dist/define/Expr.js

@@ -9,33 +9,33 @@ var __publicField = (obj, key, value) => {
 import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
-var UnOp = /* @__PURE__ */ ((UnOp2) => {
-  UnOp2["Not"] = "Not";
-  UnOp2["IsNull"] = "IsNull";
-  return UnOp2;
-})(UnOp || {});
-var BinOp = /* @__PURE__ */ ((BinOp2) => {
-  BinOp2["Add"] = "Add";
-  BinOp2["Subt"] = "Subt";
-  BinOp2["Mult"] = "Mult";
-  BinOp2["Mod"] = "Mod";
-  BinOp2["Div"] = "Div";
-  BinOp2["Greater"] = "Greater";
-  BinOp2["GreaterOrEqual"] = "GreaterOrEqual";
-  BinOp2["Less"] = "Less";
-  BinOp2["LessOrEqual"] = "LessOrEqual";
-  BinOp2["Equals"] = "Equals";
-  BinOp2["NotEquals"] = "NotEquals";
-  BinOp2["And"] = "And";
-  BinOp2["Or"] = "Or";
-  BinOp2["Like"] = "Like";
-  BinOp2["Glob"] = "Glob";
-  BinOp2["Match"] = "Match";
-  BinOp2["In"] = "In";
-  BinOp2["NotIn"] = "NotIn";
-  BinOp2["Concat"] = "Concat";
-  return BinOp2;
-})(BinOp || {});
+var UnOpType = /* @__PURE__ */ ((UnOpType2) => {
+  UnOpType2["Not"] = "Not";
+  UnOpType2["IsNull"] = "IsNull";
+  return UnOpType2;
+})(UnOpType || {});
+var BinOpType = /* @__PURE__ */ ((BinOpType2) => {
+  BinOpType2["Add"] = "Add";
+  BinOpType2["Subt"] = "Subt";
+  BinOpType2["Mult"] = "Mult";
+  BinOpType2["Mod"] = "Mod";
+  BinOpType2["Div"] = "Div";
+  BinOpType2["Greater"] = "Greater";
+  BinOpType2["GreaterOrEqual"] = "GreaterOrEqual";
+  BinOpType2["Less"] = "Less";
+  BinOpType2["LessOrEqual"] = "LessOrEqual";
+  BinOpType2["Equals"] = "Equals";
+  BinOpType2["NotEquals"] = "NotEquals";
+  BinOpType2["And"] = "And";
+  BinOpType2["Or"] = "Or";
+  BinOpType2["Like"] = "Like";
+  BinOpType2["Glob"] = "Glob";
+  BinOpType2["Match"] = "Match";
+  BinOpType2["In"] = "In";
+  BinOpType2["NotIn"] = "NotIn";
+  BinOpType2["Concat"] = "Concat";
+  return BinOpType2;
+})(BinOpType || {});
 var ExprType = /* @__PURE__ */ ((ExprType2) => {
   ExprType2["UnOp"] = "UnOp";
   ExprType2["BinOp"] = "BinOp";
@@ -113,7 +113,7 @@ function isConstant(e, value) {
     case "Param" /* Param */:
       switch (e.param.type) {
         case ParamType.Value:
-          return e.param.value == value;
+          return e.param.value === value;
         default:
           return false;
       }
@@ -178,7 +178,7 @@ var _Expr = class {
     return this.isNull().not();
   }
   isNot(that) {
-    if (that == null || that instanceof _Expr && isConstant(that.expr, null))
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
       return this.isNotNull();
     return binop(this, "NotEquals" /* NotEquals */, that);
   }
@@ -276,9 +276,9 @@ function binop(self, type, that) {
   return new Expr(ExprData.BinOp(type, self.expr, toExpr(that)));
 }
 export {
-  BinOp,
+  BinOpType,
   Expr,
   ExprData,
   ExprType,
-  UnOp
+  UnOpType
 };

package/dist/lib/Formatter.d.ts

@@ -20,17 +20,20 @@ export interface FormatContext {
     forceInline?: boolean;
     formatAsJson?: boolean;
     formatAsInsert?: boolean;
+    formatAsIn?: boolean;
     topLevel?: boolean;
 }
 type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
+export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
+}
 export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
     abstract escapeIdentifier(ident: string): string;
     abstract formatParamValue(paramValue: any): any;
     abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    compile<T>(query: Query<T>, options?: Partial<FormatContext>): Statement;
-    createContext(options?: Partial<FormatContext> & StatementOptions): {
+    compile<T>(query: Query<T>, options?: CompileOptions): Statement;
+    createContext(options?: CompileOptions): {
         stmt: Statement;
         nameResult?: string | undefined;
         skipTableName?: boolean | undefined;
@@ -38,6 +41,7 @@ export declare abstract class Formatter implements Sanitizer {
         forceInline?: boolean | undefined;
         formatAsJson?: boolean | undefined;
         formatAsInsert?: boolean | undefined;
+        formatAsIn?: boolean | undefined;
         topLevel?: boolean | undefined;
         skipNewlines?: boolean | undefined;
     };
@@ -67,7 +71,6 @@ export declare abstract class Formatter implements Sanitizer {
     formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
     formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
     formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
-    formatIn(ctx: FormatContext, expr: ExprData): Statement;
     retrieveField(expr: ExprData, field: string): ExprData | undefined;
     formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
     formatString(ctx: FormatContext, input: string): Statement;

package/dist/lib/Formatter.js

@@ -1,31 +1,31 @@
 // src/lib/Formatter.ts
 import { ColumnType } from "../define/Column.js";
-import { BinOp, Expr, ExprData, ExprType, UnOp } from "../define/Expr.js";
+import { BinOpType, Expr, ExprData, ExprType, UnOpType } from "../define/Expr.js";
 import { OrderDirection } from "../define/OrderBy.js";
 import { ParamType } from "../define/Param.js";
 import { Query, QueryType } from "../define/Query.js";
 import { Target, TargetType } from "../define/Target.js";
 import { Statement } from "./Statement.js";
 var binOps = {
-  [BinOp.Add]: "+",
-  [BinOp.Subt]: "-",
-  [BinOp.Mult]: "*",
-  [BinOp.Mod]: "%",
-  [BinOp.Div]: "/",
-  [BinOp.Greater]: ">",
-  [BinOp.GreaterOrEqual]: ">=",
-  [BinOp.Less]: "<",
-  [BinOp.LessOrEqual]: "<=",
-  [BinOp.Equals]: "=",
-  [BinOp.NotEquals]: "!=",
-  [BinOp.And]: "and",
-  [BinOp.Or]: "or",
-  [BinOp.Like]: "like",
-  [BinOp.Glob]: "glob",
-  [BinOp.Match]: "match",
-  [BinOp.In]: "in",
-  [BinOp.NotIn]: "not in",
-  [BinOp.Concat]: "||"
+  [BinOpType.Add]: "+",
+  [BinOpType.Subt]: "-",
+  [BinOpType.Mult]: "*",
+  [BinOpType.Mod]: "%",
+  [BinOpType.Div]: "/",
+  [BinOpType.Greater]: ">",
+  [BinOpType.GreaterOrEqual]: ">=",
+  [BinOpType.Less]: "<",
+  [BinOpType.LessOrEqual]: "<=",
+  [BinOpType.Equals]: "=",
+  [BinOpType.NotEquals]: "!=",
+  [BinOpType.And]: "and",
+  [BinOpType.Or]: "or",
+  [BinOpType.Like]: "like",
+  [BinOpType.Glob]: "glob",
+  [BinOpType.Match]: "match",
+  [BinOpType.In]: "in",
+  [BinOpType.NotIn]: "not in",
+  [BinOpType.Concat]: "||"
 };
 var joins = {
   left: "left",
@@ -420,21 +420,6 @@ var Formatter = class {
   formatExprValue(ctx, expr) {
     return this.formatExpr({ ...ctx, formatAsJson: false }, expr);
   }
-  formatIn(ctx, expr) {
-    const { stmt } = ctx;
-    switch (expr.type) {
-      case ExprType.Field:
-        stmt.openParenthesis();
-        stmt.raw("SELECT value FROM json_each");
-        stmt.openParenthesis();
-        this.formatExprJson(ctx, expr);
-        stmt.closeParenthesis();
-        stmt.closeParenthesis();
-        return stmt;
-      default:
-        return this.formatExprValue(ctx, expr);
-    }
-  }
   retrieveField(expr, field) {
     switch (expr.type) {
       case ExprType.Record:
@@ -458,7 +443,7 @@ var Formatter = class {
             const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
             const asJson = column?.type === ColumnType.Json && ctx.formatAsJson;
             if (asJson) {
-              stmt.add("json");
+              stmt.raw("json");
               stmt.openParenthesis();
             }
             if (asBoolean)
@@ -533,9 +518,9 @@ var Formatter = class {
     switch (expr.type) {
       case ExprType.UnOp:
         switch (expr.op) {
-          case UnOp.IsNull:
+          case UnOpType.IsNull:
             return this.formatExprValue(ctx, expr.expr).add("IS NULL");
-          case UnOp.Not:
+          case UnOpType.Not:
             stmt.raw("NOT").openParenthesis();
             this.formatExprValue(ctx, expr.expr);
             return stmt.closeParenthesis();
@@ -543,10 +528,8 @@ var Formatter = class {
       case ExprType.BinOp:
         stmt.openParenthesis();
         this.formatExprValue(ctx, expr.a).add(binOps[expr.op]).space();
-        if (expr.op === BinOp.In || expr.op === BinOp.NotIn)
-          this.formatIn(ctx, expr.b);
-        else
-          this.formatExprValue(ctx, expr.b);
+        const asIn = expr.op === BinOpType.In || expr.op === BinOpType.NotIn;
+        this.formatExprValue({ ...ctx, formatAsIn: asIn }, expr.b);
         return stmt.closeParenthesis();
       case ExprType.Param:
         switch (expr.param.type) {
@@ -555,8 +538,18 @@ var Formatter = class {
           case ParamType.Named:
             return stmt.param(expr.param);
         }
-      case ExprType.Field:
-        return this.formatField(ctx, expr.expr, expr.field);
+      case ExprType.Field: {
+        const { formatAsIn, ...rest } = ctx;
+        if (formatAsIn) {
+          stmt.openParenthesis();
+          stmt.raw("SELECT value FROM json_each");
+          stmt.openParenthesis();
+          this.formatExprJson(rest, expr);
+          stmt.closeParenthesis();
+          return stmt.closeParenthesis();
+        }
+        return this.formatField(rest, expr.expr, expr.field);
+      }
       case ExprType.Call: {
         if (expr.method === "cast") {
           const [e, type] = expr.params;
@@ -625,32 +618,48 @@ var Formatter = class {
         }
         return stmt;
       case ExprType.Filter: {
+        const { formatAsIn, ...rest } = ctx;
         const { target, condition } = expr;
         switch (target.type) {
           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.formatExprJson(ctx, target.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.formatExprJson(rest, 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();
+            this.formatExprValue(rest, condition);
+            if (!formatAsIn) {
+              stmt.closeParenthesis();
+            }
+            return stmt.closeParenthesis();
           default:
             throw new Error("todo");
         }
       }
       case ExprType.Map: {
+        const { formatAsIn, ...rest } = ctx;
         const { target, result } = expr;
         switch (target.type) {
           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);
+            stmt.openParenthesis();
+            if (!formatAsIn) {
+              stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
+            }
+            stmt.raw("SELECT").space();
+            this.formatExprJson(rest, result).add("AS result").add("FROM json_each").openParenthesis();
+            this.formatExprJson(rest, target.expr);
             stmt.closeParenthesis();
             if (target.alias)
               stmt.add("AS").addIdentifier(target.alias);
-            return stmt.closeParenthesis().closeParenthesis();
+            if (!formatAsIn) {
+              stmt.closeParenthesis();
+            }
+            return stmt.closeParenthesis();
           default:
             throw new Error("todo");
         }

package/package.json

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