rado 0.1.52 → 0.1.54

package/dist/define/Cursor.d.ts

@@ -13,6 +13,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;
     toJSON(): Query<T>;
 }
 export declare namespace Cursor {

package/dist/define/Cursor.js

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

package/dist/lib/Formatter.d.ts

@@ -4,7 +4,7 @@ import { OrderBy } from '../define/OrderBy';
 import { Query } from '../define/Query';
 import { Target } from '../define/Target';
 import { Sanitizer } from './Sanitizer';
-import { Statement } from './Statement';
+import { Statement, StatementOptions } from './Statement';
 export interface FormatContext {
     stmt: Statement;
     nameResult?: string;
@@ -30,6 +30,17 @@ export declare abstract class Formatter implements Sanitizer {
     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): {
+        stmt: Statement;
+        nameResult?: string | undefined;
+        skipTableName?: boolean | undefined;
+        tableAsExpr?: boolean | undefined;
+        forceInline?: boolean | undefined;
+        formatAsJson?: boolean | undefined;
+        formatAsDefault?: boolean | undefined;
+        topLevel?: boolean | undefined;
+        skipNewlines?: boolean | undefined;
+    };
     format<T>(ctx: FormatContext, query: Query<T>): Statement;
     formatSelect(ctx: FormatContext, query: Query.Select): Statement;
     formatInsert(ctx: FormatContext, query: Query.Insert): Statement;

package/dist/lib/Formatter.js

@@ -40,10 +40,15 @@ var Formatter = class {
   constructor() {
   }
   compile(query, options) {
-    const stmt = new Statement(this);
-    const result = this.format({ stmt, topLevel: true, ...options }, query);
+    const result = this.format(
+      this.createContext({ topLevel: true, ...options }),
+      query
+    );
     return result;
   }
+  createContext(options) {
+    return { stmt: new Statement(this, options), ...options };
+  }
   format(ctx, query) {
     switch (query.type) {
       case QueryType.Select:
@@ -419,9 +424,7 @@ var Formatter = class {
   formatIn(ctx, expr) {
     const { stmt } = ctx;
     switch (expr.type) {
-      case ExprType.Query:
-        return this.formatExprValue(ctx, expr);
-      default:
+      case ExprType.Field:
         stmt.openParenthesis();
         stmt.raw("SELECT value FROM json_each");
         stmt.openParenthesis();
@@ -429,6 +432,8 @@ var Formatter = class {
         stmt.closeParenthesis();
         stmt.closeParenthesis();
         return stmt;
+      default:
+        return this.formatExprValue(ctx, expr);
     }
   }
   retrieveField(expr, field) {
@@ -495,12 +500,11 @@ var Formatter = class {
       case Array.isArray(rawValue):
         if (formatAsDefault || formatAsJson) {
           stmt.raw("json_array");
-          stmt.openParenthesis();
         }
+        stmt.openParenthesis();
         for (const v of stmt.separate(rawValue))
           this.formatValue({ ...ctx, formatAsJson: false }, v);
-        if (formatAsDefault || formatAsJson)
-          stmt.closeParenthesis();
+        stmt.closeParenthesis();
         return stmt;
       case (typeof rawValue === "string" || typeof rawValue === "number"):
         if (forceInline)
@@ -542,7 +546,7 @@ var Formatter = class {
           case ParamType.Value:
             return this.formatValue(ctx, expr.param.value);
           case ParamType.Named:
-            return stmt.param(expr.param.name);
+            return stmt.param(expr.param);
         }
       case ExprType.Field:
         return this.formatField(ctx, expr.expr, expr.field);

package/dist/lib/Statement.d.ts

@@ -1,11 +1,15 @@
 import { ParamData } from '../define/Param';
 import { Sanitizer } from './Sanitizer';
+export interface StatementOptions {
+    skipNewlines?: boolean;
+}
 export declare class Statement {
     sanitizer: Sanitizer;
+    options: StatementOptions;
     sql: string;
-    private paramData;
+    paramData: Array<ParamData>;
     currentIndent: string;
-    constructor(sanitizer: Sanitizer, sql?: string, paramData?: Array<ParamData>);
+    constructor(sanitizer: Sanitizer, options?: StatementOptions);
     space(): this;
     add(addition: undefined | string): this;
     addLine(addition: undefined | string): this;
@@ -16,8 +20,8 @@ export declare class Statement {
     addIdentifier(name: string): this;
     value(value: any): this;
     addValue(value: any): this;
-    param(name: string): this;
-    addParam(name: string): this;
+    param(data: ParamData): this;
+    addParam(data: ParamData): this;
     raw(query: string): this;
     openParenthesis(): this;
     closeParenthesis(): this;

package/dist/lib/Statement.js

@@ -5,11 +5,12 @@ var WHITESPACE = " ";
 var NEWLINE = "\n";
 var INSERT_PARAM = "?";
 var Statement = class {
-  constructor(sanitizer, sql = "", paramData = []) {
+  constructor(sanitizer, options = {}) {
     this.sanitizer = sanitizer;
-    this.sql = sql;
-    this.paramData = paramData;
+    this.options = options;
   }
+  sql = "";
+  paramData = [];
   currentIndent = "";
   space() {
     if (this.sql === "")
@@ -35,6 +36,8 @@ var Statement = class {
     return this;
   }
   newline() {
+    if (this.options.skipNewlines)
+      return this;
     return this.raw(NEWLINE + this.currentIndent);
   }
   identifier(name) {
@@ -50,12 +53,12 @@ var Statement = class {
   addValue(value) {
     return this.space().value(value);
   }
-  param(name) {
-    this.paramData.push(ParamData.Named(name));
+  param(data) {
+    this.paramData.push(data);
     return this.raw(INSERT_PARAM);
   }
-  addParam(name) {
-    return this.space().param(name);
+  addParam(data) {
+    return this.space().param(data);
   }
   raw(query) {
     if (!query)

package/package.json

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