rado 0.2.35 → 0.2.38

package/dist/define/Column.d.ts

@@ -56,7 +56,7 @@ export declare class PrimaryColumn<T, K> extends ValueColumn<string extends K ?
     [Column.IsPrimary]: K;
 }
 export interface ObjectColumn<T> {
-    <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<X>;
+    <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<T extends null ? X | null : X>;
 }
 export declare class ObjectColumn<T> extends Callable implements Column<T> {
     [Column.Type]: T;

package/dist/define/Expr.d.ts

@@ -162,12 +162,16 @@ export declare class Expr<T> {
     sure(): Expr<NonNullable<T>>;
     get<T>(name: string): Expr<T>;
 }
+export interface ObjectExpr {
+    [Expr.Data]: ExprData;
+}
 export declare namespace Expr {
     const Data: unique symbol;
     const IsExpr: unique symbol;
     const ToExpr: unique symbol;
     const NULL: Expr<null>;
     function value<T>(value: T): 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>;
     function or(...conditions: Array<EV<boolean>>): Expr<boolean>;

package/dist/define/Expr.js

@@ -396,6 +396,10 @@ class Expr {
     return new Expr2(new ExprData.Param(new ParamData.Value(value2)));
   }
   Expr2.value = value;
+  function get(expr, field) {
+    return new Expr2(new ExprData.Field(expr[Expr2.Data], field));
+  }
+  Expr2.get = get;
   function create(input) {
     if (isExpr(input))
       return input;

package/dist/define/Fields.d.ts

@@ -1,12 +1,18 @@
-import { Expr } from './Expr.js';
+import { Column } from './Column.js';
+import { Expr, ObjectExpr } from './Expr.js';
 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<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
+type Expand<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ObjectField<T> = Expand<ObjectExpr & FieldsOf<ObjectUnion<T>>>;
 type FieldsOf<Row> = [Row] extends [Record<string, any>] ? {
     [K in keyof Row]-?: Field<Row[K]>;
 } : never;
+type Field<T> = [NonNullable<T>] extends [{
+    [Column.IsPrimary]: any;
+}] ? Expr<T> : [NonNullable<T>] extends [Array<any>] ? Expr<T> : [NonNullable<T>] extends [object] ? ObjectField<T> : Expr<T>;
 type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : [T] extends [object] ? FieldsOf<T> : Field<T>;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : Field<T>;
 export {};

package/dist/define/Schema.d.ts

@@ -7,6 +7,6 @@ export interface SchemaInstructions {
 }
 export declare namespace Schema {
     function create(schema: TableData): QueryData.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData): Array<QueryData>;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData, verbose?: boolean): Array<QueryData>;
 }
 export declare function schema(...tables: Array<Table<any>>): void;

package/dist/define/Schema.js

@@ -53,7 +53,7 @@ var Schema;
       queries.push(new QueryData.CreateIndex({ table, index }));
     return queries;
   }
-  function upgrade(formatter, local, schema2) {
+  function upgrade(formatter, local, schema2, verbose = true) {
     const columnNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.columns),
       ...Object.keys(schema2.columns)
@@ -67,16 +67,22 @@ var Schema;
         res.push(
           new QueryData.AlterTable({ table: schema2, addColumn: schemaCol })
         );
+        if (verbose)
+          console.log(`Adding column ${columnName}`);
       } else if (!schemaCol) {
         res.push(
           new QueryData.AlterTable({ table: schema2, dropColumn: columnName })
         );
+        if (verbose)
+          console.log(`Removing column ${columnName}`);
       } else {
         const { sql: instruction } = formatter.formatColumn(
           { stmt: new Statement(formatter) },
           { ...schemaCol, references: void 0 }
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          if (verbose)
+            console.log(`Recreating because ${columnName} differs`);
           recreate = true;
         }
       }
@@ -97,13 +103,19 @@ var Schema;
       const schemaIndex = meta.indexes[indexName];
       if (!localInstruction) {
         res.push(new QueryData.CreateIndex({ table: schema2, index: schemaIndex }));
+        if (verbose)
+          console.log(`Adding index ${indexName}`);
       } else if (!schemaIndex) {
         res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
+        if (verbose)
+          console.log(`Removing index ${indexName}`);
       } else {
         const { sql: instruction } = formatter.compile(
           new QueryData.CreateIndex({ table: schema2, index: schemaIndex })
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
+          if (verbose)
+            console.log(`Recreating index ${indexName}`);
           res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
           res.push(
             new QueryData.CreateIndex({ table: schema2, index: schemaIndex })

package/dist/lib/Formatter.js

@@ -678,7 +678,7 @@ class Formatter {
     const { stmt } = ctx;
     if (!ctx.formatAsJson) {
       stmt.openParenthesis();
-      this.format(ctx, expr.query);
+      this.format({ ...ctx, formatAsIn: false }, expr.query);
       return stmt.closeParenthesis();
     }
     if (expr.query.singleResult) {

package/package.json

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