rado 0.2.29 → 0.2.30

package/dist/define/Column.d.ts

@@ -23,9 +23,9 @@ export interface ColumnData extends PartialColumnData {
     type: ColumnType;
     name: string;
 }
-export interface Column<T> {
-    [Column.Type]: T;
-    [Column.Data]: PartialColumnData;
+export declare class Column<T> {
+    get [Column.Type](): T;
+    get [Column.Data](): PartialColumnData;
 }
 export declare namespace Column {
     const Data: unique symbol;

package/dist/define/Expr.d.ts

@@ -171,5 +171,8 @@ export declare namespace Expr {
     function create<T>(input: EV<T>): Expr<T>;
     function and(...conditions: Array<EV<boolean>>): Expr<boolean>;
     function or(...conditions: Array<EV<boolean>>): Expr<boolean>;
+    function hasExpr<T>(input: any): input is {
+        [Expr.ToExpr](): Expr<T>;
+    };
     function isExpr<T>(input: any): input is Expr<T>;
 }

package/dist/define/Expr.js

@@ -135,7 +135,7 @@ var ExprData;
   function create(input) {
     if (input === null || input === void 0)
       return new ExprData2.Param(new ParamData.Value(null));
-    if (input && (typeof input === "function" || typeof input === "object") && input[Expr.ToExpr])
+    if (Expr.hasExpr(input))
       input = input[Expr.ToExpr]();
     if (Expr.isExpr(input))
       return input[Expr.Data];
@@ -411,6 +411,10 @@ var Expr = class {
     return conditions.map(create).reduce((condition, expr) => condition.or(expr), value(false));
   }
   Expr2.or = or;
+  function hasExpr(input) {
+    return input && (typeof input === "function" || typeof input === "object") && input[Expr2.ToExpr];
+  }
+  Expr2.hasExpr = hasExpr;
   function isExpr(input) {
     return input !== null && (typeof input === "object" || typeof input === "function") && input[Expr2.IsExpr];
   }

package/dist/define/Table.d.ts

@@ -4,6 +4,7 @@ import { EV, Expr } from './Expr';
 import type { Fields } from './Fields';
 import { Index, IndexData } from './Index';
 import type { Selection } from './Selection';
+import { SelectSingle } from './query/Select';
 import { TableSelect } from './query/TableSelect';
 interface TableDefinition {
 }
@@ -28,18 +29,21 @@ export declare class TableInstance<Definition> {
     get [Table.Data](): TableData;
 }
 export type Table<Definition> = Definition & TableInstance<Definition>;
+type TableOf<Row> = Table<{
+    [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
+}>;
+type RowOf<Definition> = {
+    [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? T : never;
+};
+type UpdateOf<Definition> = Partial<{
+    [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? EV<T> | SelectSingle<T> : never;
+}>;
 export declare namespace Table {
     export const Data: unique symbol;
     export const Meta: unique symbol;
-    export type Of<Row> = Table<{
-        [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
-    }>;
-    export type Select<Definition> = {
-        [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? T : never;
-    };
-    export type Update<Definition> = Partial<{
-        [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? EV<T> : never;
-    }>;
+    export type Of<Row> = TableOf<Row>;
+    export type Select<Definition> = RowOf<Definition>;
+    export type Update<Definition> = UpdateOf<Definition>;
     type IsOptional<K> = K extends PrimaryColumn<any, any> ? true : K extends OptionalColumn<any> ? true : K extends Column<infer V> ? null extends V ? true : false : never;
     export type Insert<Definition> = {
         [K in keyof Definition as true extends IsOptional<Definition[K]> ? K : never]?: Definition[K] extends Column<infer V> ? EV<V> : never;
@@ -54,7 +58,7 @@ export interface TableMeta {
 interface Define<T> {
     new (): T;
 }
-export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
+export type table<T> = Table.Select<T extends Table<infer D> ? D : T>;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
 export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {

package/dist/define/query/Select.d.ts

@@ -15,7 +15,7 @@ export declare class SelectMultiple<Row> extends Union<Row> {
     count(): SelectSingle<number>;
     orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<Row>;
     groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<Row>;
-    maybeFirst(): SelectSingle<Row | undefined>;
+    maybeFirst(): SelectSingle<Row | null>;
     first(): SelectSingle<Row>;
     where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
     take(limit: number | undefined): SelectMultiple<Row>;

package/dist/define/query/TableSelect.d.ts

@@ -13,7 +13,7 @@ export declare class TableSelect<Definition> extends SelectMultiple<Table.Select
     as(alias: string): Table<Definition>;
     create(): CreateTable;
     insertSelect(query: SelectMultiple<Table.Insert<Definition>>): Inserted;
-    insertOne(record: Table.Insert<Definition>): Query<Table.Select<Definition>>;
+    insertOne(record: Table.Insert<Definition>): Query<{ [K in keyof Definition as Definition[K] extends import("../Column").Column<any> ? K : never]: Definition[K] extends import("../Column").Column<infer T> ? T : never; }>;
     insertAll(data: Array<Table.Insert<Definition>>): Inserted;
     set(data: Table.Update<Definition>): Update<Definition>;
     delete(): Delete;

package/dist/lib/Driver.js

@@ -99,7 +99,7 @@ var SyncDriver = class extends DriverBase {
             const row = res[0];
             if (query.validate && row === void 0)
               throw new Error("No row found");
-            return row;
+            return row ?? null;
           }
           return res;
         } else if (query.type === QueryType.Raw) {
@@ -215,7 +215,7 @@ var AsyncDriver = class extends DriverBase {
             const row = res[0];
             if (query.validate && row === void 0)
               throw new Error("No row found");
-            return row;
+            return row ?? null;
           }
           return res;
         } else if (query.type === QueryType.Raw) {

package/dist/lib/Formatter.js

@@ -165,11 +165,13 @@ var Formatter = class {
     const keys = Object.keys(data).filter((key) => query.table.columns[key]);
     for (const key of stmt.separate(keys)) {
       stmt.identifier(key).add("=").space();
-      const value = data[key];
-      if (Expr.isExpr(value))
+      let input = data[key];
+      if (Expr.hasExpr(input))
+        input = input[Expr.ToExpr]();
+      if (Expr.isExpr(input))
         this.formatExprJson(ctx, ExprData.create(data[key]));
       else
-        this.formatValue({ ...ctx, formatAsInsert: true }, value);
+        this.formatValue({ ...ctx, formatAsInsert: true }, input);
     }
     this.formatWhere(ctx, query.where);
     this.formatLimit(ctx, query);

package/package.json

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