rado 0.2.28 → 0.2.30

package/dist/define/Column.d.ts

@@ -8,7 +8,7 @@ export declare enum ColumnType {
     Boolean = "Boolean",
     Json = "Json"
 }
-interface PartialColumnData {
+export interface PartialColumnData {
     type?: ColumnType;
     name?: string;
     nullable?: boolean;
@@ -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;
@@ -35,10 +35,10 @@ export declare namespace Column {
     const IsPrimary: unique symbol;
     function isColumn<T>(input: any): input is Column<T>;
 }
-interface ValueColumn<T> extends Expr<T> {
+export interface ValueColumn<T> extends Expr<T> {
     <X extends T = T>(): ValueColumn<T extends null ? X | null : X>;
 }
-declare class ValueColumn<T> extends Callable implements Column<T> {
+export declare class ValueColumn<T> extends Callable implements Column<T> {
     [Column.Type]: T;
     [Column.Data]: PartialColumnData;
     constructor(data: PartialColumnData);
@@ -52,13 +52,13 @@ declare class ValueColumn<T> extends Callable implements Column<T> {
 export declare class OptionalColumn<T> extends ValueColumn<T> {
     [Column.IsOptional]: true;
 }
-export declare class PrimaryColumn<T, K> extends ValueColumn<PrimaryKey<T, K>> {
+export declare class PrimaryColumn<T, K> extends ValueColumn<string extends K ? T : PrimaryKey<T, K>> {
     [Column.IsPrimary]: K;
 }
-interface ObjectColumn<T> {
+export interface ObjectColumn<T> {
     <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<X>;
 }
-declare class ObjectColumn<T> extends Callable implements Column<T> {
+export declare class ObjectColumn<T> extends Callable implements Column<T> {
     [Column.Type]: T;
     [Column.Data]: PartialColumnData;
     constructor(data: PartialColumnData);
@@ -69,14 +69,14 @@ declare class ObjectColumn<T> extends Callable implements Column<T> {
 export declare class OptionalObjectColumn<T> extends ObjectColumn<T> {
     [Column.IsOptional]: true;
 }
-export type PrimaryKey<T, K> = string extends K ? T : T & {
+export type PrimaryKey<T, K> = T & {
     [Column.IsPrimary]: K;
 };
 type DefaultValue<T> = EV<T> | (() => EV<T>);
-interface UnTyped {
+export interface UnTyped {
     (name: string): UnTyped;
 }
-declare class UnTyped extends Callable {
+export declare class UnTyped extends Callable {
     [Column.Data]: PartialColumnData;
     constructor(data?: PartialColumnData);
     get nullable(): NullableUnTyped;
@@ -89,7 +89,7 @@ declare class UnTyped extends Callable {
     get object(): ObjectColumn<{}>;
     get array(): ValueColumn<any[]>;
 }
-declare class NullableUnTyped {
+export declare class NullableUnTyped {
     [Column.Data]: PartialColumnData;
     get unique(): UnTyped;
     get string(): ValueColumn<string | null>;

package/dist/define/Column.js

@@ -150,8 +150,11 @@ var column = new UnTyped();
 export {
   Column,
   ColumnType,
+  ObjectColumn,
   OptionalColumn,
   OptionalObjectColumn,
   PrimaryColumn,
+  UnTyped,
+  ValueColumn,
   column
 };

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/index.d.ts

@@ -13,6 +13,7 @@ export type { Selection } from './define/Selection';
 export * from './define/Sql';
 export * from './define/Table';
 export * from './define/Target';
+export * from './define/VirtualTable';
 export type { Driver } from './lib/Driver';
 export type { FormatContext, Formatter } from './lib/Formatter';
 export type { Sanitizer } from './lib/Sanitizer';

package/dist/index.js

@@ -11,4 +11,5 @@ export * from "./define/Schema.js";
 export * from "./define/Sql.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
+export * from "./define/VirtualTable.js";
 export * from "./lib/SqlError.js";

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.28",
+  "version": "0.2.30",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",