@grest-ts/sql 0.0.52 → 0.0.56

package/src/SqlExpression.ts

@@ -17,9 +17,9 @@ export class SqlExpression<TableRef, Name extends string | unknown | undefined,
 
     public readonly expression: string;
     public readonly nameAs: Name | undefined;
-    public readonly transformer: Transformer<unknown, Type>
+    public readonly transformer: Transformer<any, Type> | undefined
 
-    constructor(expression: string, nameAs?: Name, parser?: Transformer<unknown, Type>) {
+    constructor(expression: string, nameAs?: Name, parser?: Transformer<any, Type>) {
         this.expression = expression;
         this.nameAs = nameAs;
         this.transformer = parser;
@@ -132,8 +132,8 @@ export class SqlExpressionWithOver<TableRef, Name, Type extends string | number
     //public over<WindowName extends string>(namedWindow: WindowName): Expr<TableRef | `${WINDOW} as ${WindowName}`, unknown, Type>
     public over<WindowName extends string, TableRef1>(namedWindow: WindowName, func: (builder: Over<TableRef1>) => void): Expr<TableRef | TableRef1 | `(window) as ${WindowName}`, unknown, Type>
     public over(a: any, b?: any): any {
-        let namedWindow: string = undefined;
-        let func: (builder: Over<never>) => void = undefined;
+        let namedWindow: string | undefined = undefined;
+        let func: ((builder: Over<never>) => void) | undefined = undefined;
         if (typeof a === "function") {
             func = a
         } else if (typeof a === "string") {
@@ -143,7 +143,7 @@ export class SqlExpressionWithOver<TableRef, Name, Type extends string | number
             }
         }
         const builder = new Over<{}>();
-        func(builder);
+        func!(builder);
         return SqlExpression.create(this.expression + " OVER (" + (namedWindow ? escapeId(namedWindow) + " " : "") + builder.toString() + ")");
     }
 
@@ -151,8 +151,8 @@ export class SqlExpressionWithOver<TableRef, Name, Type extends string | number
 
 export class Over<TableRef> {
 
-    private _partitionBy: string[];
-    private _orderBy: string[];
+    private _partitionBy: string[] | undefined;
+    private _orderBy: string[] | undefined;
 
     public orderBy<TableRef2>(...cols: OrderByStructure<Expr<TableRef2, string, any>>): Over<TableRef | TableRef2> {
         this._orderBy = orderByStructureToSqlString(cols)
@@ -165,8 +165,8 @@ export class Over<TableRef> {
     }
 
     public toString() {
-        return (this._partitionBy?.length > 0 ? " PARTITION BY " + this._partitionBy.join(", ") : "") +
-            (this._orderBy?.length > 0 ? " ORDER BY " + this._orderBy.join(", ") : "")
+        return (this._partitionBy && this._partitionBy.length > 0 ? " PARTITION BY " + this._partitionBy.join(", ") : "") +
+            (this._orderBy && this._orderBy.length > 0 ? " ORDER BY " + this._orderBy.join(", ") : "")
     }
 
 }

package/src/SqlFunctions.ts

@@ -230,7 +230,7 @@ export function GROUP_CONCAT<TableRef, TableRef2 = never>(
     call?: (arg: GroupConcat<TableRef2>) => GroupConcat<TableRef2>
 ): Expr<TableRef | TableRef2, unknown, string> {
     const builder = new GroupConcat();
-    call(builder);
+    call!(builder);
     return SqlExpression.create("GROUP_CONCAT(" + builder.toString() + ")");
 }
 
@@ -240,7 +240,7 @@ export class GroupConcat<TableRef = never> {
     private _columns: any[] = [];
     private _distinct: boolean = false;
     private _orderBy: string[] = [];
-    private _separator: string = undefined;
+    private _separator: string | undefined = undefined;
 
     public all<TableRef2>(...args: (string | PrepareQueryArgument | Expr<TableRef2, any, any>)[]): GroupConcat<TableRef | TableRef2> {
         this._columns = args.map(toSql);
@@ -292,7 +292,7 @@ export function UNIX_TIMESTAMP<Name, TableRef>(field: Expr<TableRef, Name, tDate
     return SqlExpression.create("UNIX_TIMESTAMP(" + field.expression + ")")
 }
 
-export function DATE<Name, TableRef>(field: Expr<TableRef, Name, tDate | tDateTime>): Expr<TableRef, Name, tDate> {
+export function DATE<Name, TableRef>(field: Expr<TableRef, Name, tDate | tDateTime | null>): Expr<TableRef, Name, tDate> {
     return SqlExpression.create("DATE(" + field.expression + ")")
 }
 

package/src/_dedupCheck.ts

@@ -12,7 +12,7 @@
 const __KEY = Symbol.for("grest-ts:dedup:@grest-ts/sql");
 const __slot = globalThis as Record<symbol, unknown>;
 const __existing = __slot[__KEY] as { path: string; version: string } | undefined;
-const __here = { path: import.meta.url, version: "0.0.52" };
+const __here = { path: import.meta.url, version: "0.0.56" };
 // Same path + same version means the same physical package is being
 // re-evaluated by a different ESM runner (e.g. vitest projects share one
 // process but each project has its own module cache). That isn't a true

package/src/delete/DeleteBuilder.ts

@@ -12,14 +12,14 @@ export class DeleteBuilder<Tables, Entity> implements DeleteWhereMethods<Tables>
     GatewayDeleteWhereMethods<Entity>,
     GatewayDeleteOrderByMethods<Entity> {
 
-    public readonly [SQL_ENTITY]: undefined; // never used
+    public readonly [SQL_ENTITY]!: { affectedRows: number }; // phantom, never populated
 
-    private _from: string;
+    private _from: string = "";
     private readonly _where: string[] = [];
     private readonly _orderBy: string[] = [];
-    private _limit: string;
+    private _limit: string = "";
 
-    public from(table: string, alias: string): this {
+    public from(table: string, alias?: string): this {
         this._from = table + (alias ? " as " + escapeId(alias) : "");
         return this;
     }

package/src/insert/InsertBuilder.ts

@@ -4,17 +4,17 @@ import {SQL_ENTITY, SQL_EXPRESSION} from "../Symbols";
 
 export class InsertBuilder<Entity> implements ExecInsertMethods, InsertSetMethods<Entity> {
 
-    public readonly [SQL_ENTITY]: undefined; // never used
+    public readonly [SQL_ENTITY]!: { insertId: number }; // phantom, never populated
 
     private _ignore: boolean = false;
-    private _tableName: string;
+    private _tableName: string = "";
 
     private _set: string[] = []
 
-    private _valueNames: Set<string>;
-    private _valuesObjects: any[];
+    private _valueNames: Set<string> = new Set();
+    private _valuesObjects: any[] = [];
 
-    private _select: string;
+    private _select: string = "";
 
 
     public to(tableName: string) {

package/src/select/SelectBuilder.ts

@@ -36,10 +36,10 @@ export class SelectBuilder<Result, Aliases, AliasesFromWith, Tables> implements
     GatewaySelectOrderByMethods<Result, Tables>,
     GatewaySelectLimitMethods<Result> {
 
-    public readonly [SQL_ENTITY]: undefined; // never used
+    public readonly [SQL_ENTITY]!: Result; // phantom, never populated
 
     private _withQueries: Map<string, string> = new Map()
-    private _from: string;
+    private _from: string = "";
     private readonly _columns: string[] = [];
     private _columnStruct: DbTableDefinition<any> = {} as any;
 
@@ -49,7 +49,7 @@ export class SelectBuilder<Result, Aliases, AliasesFromWith, Tables> implements
     private readonly _having: string[] = []
     private readonly _groupBy: string[] = []
     private _orderBy: string[] = []
-    private _limit: string = undefined
+    private _limit: string = ""
 
     private readonly unions: string[] = []
     private _unionColumnOrder: string[] = []

package/src/select/parts/S2Columns.ts

@@ -26,27 +26,33 @@ export interface ColumnsMethods<Result, Tables> {
  * Take array of Col-s and convert to Record<key, value> & ... object.
  */
 export type ExtractObj<Columns extends Expr<any, string, any>[]> = {
-    [K in Columns[number]['nameAs']]: Extract<Columns[number], { nameAs: K }>['type']
+    [K in NonNullable<Columns[number]['nameAs']> & (string | number | symbol)]: _ColumnTypeByName<Columns[number], K>
 }
 
+type _ColumnTypeByName<Column, K> = Column extends { nameAs: infer N, type: infer T }
+    ? K extends NonNullable<N> ? T : never
+    : never
+
 
 // --------------------------------------------------------------------
 
 type _checkIfExistsInOtherFields<Rest extends any[], Expr> =
     Rest extends []
         ? Expr
-        : Expr extends { nameAs: string } ?
-            Expr["nameAs"] extends (Rest extends { nameAs: infer A }[] ? A : never)
-                ? `'${Expr["nameAs"]}' already exists in columns!`
-                : Expr
-            : Expr extends { nameAs: unknown } ?
-                `Is missing column name. Add .as('name')`
-                : Expr
+        : Expr extends { nameAs: infer N } ?
+            [NonNullable<N>] extends [string] ?
+                NonNullable<N> extends (Rest extends { nameAs: infer A }[] ? NonNullable<A> : never)
+                    ? `'${NonNullable<N>}' already exists in columns!`
+                    : Expr
+                : `Is missing column name. Add .as('name')`
+            : Expr
 
 type _checkIfExistsInResult<Result, Expr> =
-    Expr extends { nameAs: string } ?
-        Expr["nameAs"] extends keyof Result
-            ? `'${Expr["nameAs"]}' already exists in result columns!`
+    Expr extends { nameAs: infer N } ?
+        [NonNullable<N>] extends [string] ?
+            NonNullable<N> extends keyof Result
+                ? `'${NonNullable<N> & string}' already exists in result columns!`
+                : Expr
             : Expr
         : Expr
 

package/src/update/UpdateBuilder.ts

@@ -13,14 +13,14 @@ export class UpdateBuilder<Entity, Tables> implements ExecUpdateMethods,
     UpdateOrderByMethods<Tables>,
     UpdateLimitMethods {
 
-    public readonly [SQL_ENTITY]: { affectedRows: number; }; // never used
+    public readonly [SQL_ENTITY]!: { affectedRows: number; }; // phantom, never populated
 
-    private _tableName: string;
+    private _tableName: string = "";
     private _joins: string[] = [];
     private _set: string[] = []
     private readonly _where: string[] = [];
     private readonly _orderBy: string[] = [];
-    private _limit: string;
+    private _limit: string = "";
     private _ignore: boolean = false;
 
     public in(tableName: string, alias?: string) {