rado 0.1.25 → 0.1.27

package/dist/lib/Formatter.d.ts

@@ -16,6 +16,7 @@ export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
     abstract escapeIdentifier(ident: string): string;
+    abstract formatParamValue(paramValue: any): any;
     abstract formatSqlAccess(on: Statement, field: string): Statement;
     abstract formatJsonAccess(on: Statement, field: string): Statement;
     formatAccess(on: Statement, field: string, formatAsJson?: boolean): Statement;

package/dist/lib/Sanitizer.d.ts

@@ -1,4 +1,5 @@
 export interface Sanitizer {
     escapeValue(value: any): string;
     escapeIdentifier(ident: string): string;
+    formatParamValue(paramValue: any): any;
 }

package/dist/lib/Statement.d.ts

@@ -53,9 +53,10 @@ export declare class Statement {
     compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
 }
 export declare class CompiledStatement {
+    sanitizer: Sanitizer;
     sql: string;
     private paramData;
-    constructor(sql: string, paramData: Array<ParamData>);
+    constructor(sanitizer: Sanitizer, sql: string, paramData: Array<ParamData>);
     params(input?: Record<string, any>): Array<any>;
     toString(): string;
 }

package/dist/lib/Statement.js

@@ -148,7 +148,7 @@ var Statement = class {
             sql += sanitizer.escapeValue(token.data);
           } else {
             sql += "?";
-            paramData.push(ParamData.Value(token.data ?? null));
+            paramData.push(ParamData.Value(token.data));
           }
           break;
         case "Param" /* Param */:
@@ -163,22 +163,23 @@ var Statement = class {
           break;
       }
     }
-    return new CompiledStatement(sql, paramData);
+    return new CompiledStatement(sanitizer, sql, paramData);
   }
 };
 var CompiledStatement = class {
-  constructor(sql, paramData) {
+  constructor(sanitizer, sql, paramData) {
+    this.sanitizer = sanitizer;
     this.sql = sql;
     this.paramData = paramData;
   }
   params(input) {
     return this.paramData.map((param2) => {
       if (param2.type === ParamType.Named) {
-        if (input?.[param2.name] === void 0)
-          throw new TypeError(`Missing parameter ${param2.name}`);
-        return input[param2.name];
+        if (input && param2.name in input)
+          return this.sanitizer.formatParamValue(input[param2.name]);
+        throw new TypeError(`Missing parameter ${param2.name}`);
       }
-      return param2.value;
+      return this.sanitizer.formatParamValue(param2.value);
     });
   }
   toString() {

package/dist/sqlite/SqliteFormatter.d.ts

@@ -2,6 +2,7 @@ import { ExprData } from '../lib/Expr';
 import { FormatContext, Formatter } from '../lib/Formatter';
 import { Statement } from '../lib/Statement';
 export declare class SqliteFormatter extends Formatter {
+    formatParamValue(paramValue: any): any;
     escapeValue(value: any): string;
     escapeIdentifier(input: string): string;
     escapeString(input: string): string;

package/dist/sqlite/SqliteFormatter.js

@@ -15,6 +15,17 @@ function escapeWithin(input, outer) {
   return buf;
 }
 var SqliteFormatter = class extends Formatter {
+  formatParamValue(paramValue) {
+    if (paramValue === null || paramValue === void 0)
+      return null;
+    if (typeof paramValue === "boolean")
+      return paramValue ? 1 : 0;
+    if (typeof paramValue === "number")
+      return paramValue;
+    if (typeof paramValue === "string")
+      return paramValue;
+    return JSON.stringify(paramValue);
+  }
   escapeValue(value) {
     if (value === null || value === void 0)
       return "null";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "license": "MIT",
   "type": "module",
   "exports": {