rado 0.1.11 → 0.1.12

package/dist/Fields.d.ts

@@ -1,10 +1,9 @@
 import { Column } from './Column';
 import { Expr } from './Expr';
-type GetKeys<U> = U extends Record<infer K, any> ? K : never;
-type UnionToIntersection<U> = {
-    [K in GetKeys<U>]: U extends Record<K, infer T> ? T : never;
+type ObjectUnion<T> = {
+    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
 };
-type RecordField<T> = Expr<T> & FieldsOf<UnionToIntersection<T>>;
+type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
 type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.Primary<infer K, infer V>] ? Expr<string extends K ? V : V & {
     [Column.isPrimary]: K;
 }> : [T] extends [Column.Optional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;

package/dist/Formatter.d.ts

@@ -8,6 +8,7 @@ import { Target } from './Target';
 export interface FormatContext {
     nameResult?: string;
     skipTableName?: boolean;
+    forceInline?: boolean;
     formatAsJson?: boolean;
     formatSubject?: (subject: Statement) => Statement;
 }
@@ -50,6 +51,6 @@ export declare abstract class Formatter implements Sanitizer {
     formatField(expr: ExprData, field: string, ctx: FormatContext): Statement;
     formatString(input: string): Statement;
     formatInlineValue(rawValue: any): Statement;
-    formatValue(rawValue: any, formatAsJson?: boolean): Statement;
+    formatValue(rawValue: any, ctx: FormatContext): Statement;
     formatExpr(expr: ExprData, ctx: FormatContext): Statement;
 }

package/dist/Formatter.js

@@ -124,7 +124,11 @@ var Formatter = class {
     return raw("create index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
       separated(
         query.index.on.map(
-          (expr) => this.formatExprValue(expr, { ...ctx, skipTableName: true })
+          (expr) => this.formatExprValue(expr, {
+            ...ctx,
+            skipTableName: true,
+            forceInline: true
+          })
         )
       )
     ).add(this.formatWhere(query.where, ctx));
@@ -349,7 +353,8 @@ var Formatter = class {
         return this.formatString(JSON.stringify(rawValue));
     }
   }
-  formatValue(rawValue, formatAsJson) {
+  formatValue(rawValue, ctx) {
+    const { formatAsJson, forceInline } = ctx;
     switch (true) {
       case (rawValue === null || rawValue === void 0):
         return raw("null");
@@ -357,10 +362,16 @@ var Formatter = class {
         return rawValue ? raw("1") : raw("0");
       case Array.isArray(rawValue):
         const res = parenthesis(
-          separated(rawValue.map((v) => this.formatValue(v, false)))
+          separated(
+            rawValue.map(
+              (v) => this.formatValue(v, { ...ctx, formatAsJson: false })
+            )
+          )
         );
         return formatAsJson ? raw("json_array").concat(res) : res;
       case (typeof rawValue === "string" || typeof rawValue === "number"):
+        if (forceInline)
+          return raw(this.escapeValue(rawValue));
         return value(rawValue);
       default:
         const expr = this.formatString(JSON.stringify(rawValue));
@@ -389,7 +400,7 @@ var Formatter = class {
       case ExprType.Param:
         switch (expr.param.type) {
           case ParamType.Value:
-            return this.formatValue(expr.param.value, ctx.formatAsJson);
+            return this.formatValue(expr.param.value, ctx);
           case ParamType.Named:
             throw new Error("todo");
         }

package/package.json

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