tspace-mysql 1.9.0 → 1.9.1-beta.2

package/dist/lib/types/index.d.ts

@@ -3,13 +3,31 @@ import { TCache as Cache } from '../core/Cache';
 import { CONSTANTS } from '../constants';
 import { Join } from "../core/Join";
 import { QueryBuilder } from "../core/Driver";
-import { TResult } from "../core";
+import { T, TResult } from "../core";
 import { TResultDecorator } from "./decorator";
 export type TCache = Cache;
+export type TCacheModel = {
+    provider: () => string;
+    driver: (driver: "db" | "memory" | "redis") => any;
+    all: () => Promise<any[]>;
+    clear: () => Promise<void>;
+    get: (key: string, options?: {
+        namespace?: boolean;
+    }) => Promise<any>;
+    exists: (key: string, options?: {
+        namespace?: boolean;
+    }) => Promise<boolean>;
+    set: (key: string, value: unknown, ms: number, options?: {
+        namespace?: boolean;
+    }) => Promise<void>;
+    delete: (key: string, options?: {
+        namespace?: boolean;
+    }) => Promise<void>;
+};
 export type TConstant = typeof CONSTANTS;
 export type TRelationOptions<K = any> = {
     name: K;
-    model: new () => Model<any, any>;
+    model: new () => Model<any, any, any>;
     as?: string;
     localKey?: string;
     foreignKey?: string;
@@ -17,7 +35,7 @@ export type TRelationOptions<K = any> = {
     pivot?: string;
     query?: any;
     queryPivot?: any;
-    relation?: Object;
+    relation?: string;
     exists?: boolean;
     notExists?: boolean;
     all?: boolean;
@@ -28,7 +46,7 @@ export type TRelationOptions<K = any> = {
 };
 export type TRelationQueryOptions<K = any> = {
     name: K extends void ? never : K;
-    model: new () => Model<any, any>;
+    model: new () => Model<any, any, any>;
     as?: string;
     localKey?: string;
     foreignKey?: string;
@@ -58,10 +76,12 @@ export type TPagination<K = any> = {
         last_page: number;
         next_page: number;
         prev_page: number;
-        currentPage: number;
-        lastPage: number;
-        nextPage: number;
-        prevPage: number;
+        page: {
+            prev: number;
+            next: number;
+            current: number;
+            last: number;
+        };
     };
     data: K[];
 };
@@ -113,7 +133,6 @@ export type TPoolCallback = {
     release: () => void;
 };
 export type TConnectionTransaction = {
-    on: (event: TPoolEvent, data: any) => void;
     query: (sql: string) => Promise<any[]>;
     /**
      * The 'startTransaction' method is used when need to started the transaction
@@ -135,6 +154,11 @@ export type TConnectionTransaction = {
      * @returns {Promise<void>}
      */
     end: () => Promise<void>;
+    /**
+     * The 'release' method is used to release connection
+     * @returns {Promise<void>}
+     */
+    release: () => Promise<void>;
 };
 export type TConnection = {
     on: (event: TPoolEvent, data: any) => void;
@@ -144,6 +168,7 @@ export type TConnection = {
     commit: () => Promise<void>;
     rollback: () => Promise<void>;
     end: () => Promise<void>;
+    release: () => Promise<void>;
 };
 export type TPoolConnected = {
     database: () => string;
@@ -151,13 +176,14 @@ export type TPoolConnected = {
     queryBuilder: typeof QueryBuilder;
     query: (sql: string) => Promise<any[]>;
     connection: () => Promise<TConnection>;
+    end: () => Promise<void>;
 };
 export type TModelOrObject = {
-    model: new () => Model<any, any>;
+    model: new () => Model<any, any, any>;
     alias?: string;
     key?: string;
     join?: Join;
-} | (new () => Model<any, any>);
+} | (new () => Model<any, any, any>);
 export type TCreateNewConnection = {
     on: (event: TPoolEvent, data: (r: any) => any) => void;
     query: (sql: string) => Promise<any>;
@@ -271,7 +297,11 @@ export type TSchemaKeys<T> = keyof {
 } extends never ? string : keyof {
     [K in keyof T as string extends K ? never : K]: T[K];
 };
-export type TRelationResults<T> = T extends Array<infer A> ? TRelationResults<A>[] : T extends object ? {
+export type TRelationResults<T> = T extends Array<infer A> ? TRelationResults<A>[] : T extends {
+    __isDefault: true;
+} ? TDefault<T extends {
+    value: infer V;
+} ? V extends Date ? Date : V extends string ? string : V extends number ? number : V extends boolean ? boolean : V : string> : T extends Date ? T : T extends object ? {
     [K in keyof T as K extends `$${string}` ? never : K]: TRelationResults<T[K]>;
 } : T;
 export type TRelationKeys<T> = {
@@ -291,7 +321,7 @@ export type TLiteralStringKeys<T> = {
     [K in keyof T]: T[K] extends string ? (string extends T[K] ? never : K) : never;
 }[keyof T];
 export type TLiteralEnumKeys<T> = TLiteralStringKeys<TRemoveIndexSignature<T>>;
-export type TDriver = 'pg' | 'postgres' | 'mysql' | 'mysql2' | 'mariadb' | 'mssql' | 'sqlite3';
+export type TDriver = 'pg' | 'postgres' | 'mysql' | 'mysql2' | 'mariadb' | 'mssql' | 'sqlite' | 'mongodb';
 export type TPoolCusterOptions = {
     writer: {
         host: string;
@@ -326,27 +356,87 @@ export type TPoolCusterConnected = {
     masters: TClusterPool[];
     slaves: TClusterPool[];
 };
-export type TIsEnum<T> = string extends T ? false : number extends T ? false : boolean extends T ? false : [
+export type TIsEnum<T> = T extends {
+    __isDefault: true;
+} ? false : string extends T ? false : number extends T ? false : boolean extends T ? false : [
     T
 ] extends [string | number] ? true : false;
 export type TLifecycle = "beforeInsert" | "afterInsert" | "beforeUpdate" | "afterUpdate" | "beforeRemove" | "afterRemove";
-export type TDeepExpand<T> = T extends Date ? T : T extends Function ? T : T extends Model ? T : T extends (infer U)[] ? TDeepExpand<U>[] : T extends object ? {
+export type TDeepOmit<T, Filter> = T extends infer ObjectType ? {
+    [K in keyof ObjectType as K extends keyof Filter ? Filter[K] extends true ? never : K : NonNullable<ObjectType[K]> extends object ? (NonNullable<ObjectType[K]> extends Date ? K : never) : K]: K extends keyof Filter ? Filter[K] extends object ? TDeepOmit<NonNullable<ObjectType[K]>, Filter[K]> : ObjectType[K] : ObjectType[K];
+} : never;
+export type TDeepExpand<T> = T extends TDefault<infer U> ? TDefault<U extends boolean ? boolean : U extends number ? number : U extends string ? string : U> : T extends Date ? T : T extends Function ? T : T extends Model ? T : T extends (infer U)[] ? TDeepExpand<U>[] : T extends object ? {
     [K in keyof T]: TDeepExpand<T[K]>;
 } : T;
-export type TResultResolved<M extends Model, K = {}> = (unknown extends TResult<M> ? unknown extends TResultDecorator<M> ? Record<K & string, any> : {} extends TResultDecorator<M> ? Record<K & string, any> : TResultDecorator<K & M> : TResult<K & M>);
-export type TFilter<T, S> = {
-    [K in keyof T & keyof S]: S[K] extends true ? NonNullable<T[K]> : S[K] extends object ? NonNullable<T[K]> extends (infer U)[] ? TDeepExpand<TFilter<U, S[K]>>[] : NonNullable<T[K]> extends object ? TDeepExpand<TFilter<NonNullable<T[K]>, S[K]>> : never : never;
-};
-export type TResultFilterResolved<T, S> = S extends undefined ? T : TDeepExpand<TFilter<T, S>>;
-export type TSelectionMerger<T1, T2> = {
-    [K in keyof T1 | Exclude<keyof T2, keyof T1>]: K extends keyof T1 ? K extends keyof T2 ? T1[K] extends true ? true : T1[K] extends object ? T2[K] extends object ? TSelectionMerger<T1[K], ((T2[K] extends {
-        select: infer S;
-    } ? S : {}) & (T2[K] extends {
-        relations: infer R;
-    } ? R : {}) & Omit<T2[K], 'select' | 'relations'>)> : T1[K] : T1[K] : T1[K] : K extends keyof T2 ? T2[K] extends object ? TSelectionMerger<{}, ((T2[K] extends {
-        select: infer S;
-    } ? S : {}) & (T2[K] extends {
-        relations: infer R;
-    } ? R : {}) & Omit<T2[K], 'select' | 'relations'>)> : T2[K] : never;
+export type TResultResolved<M extends Model> = (unknown extends TResult<M> ? unknown extends TResultDecorator<M> ? Record<string, any> : {} extends TResultDecorator<M> ? Record<string, any> : TResultDecorator<M> : TResult<M>) extends infer $Resolved ? {
+    [K in keyof $Resolved]: [Exclude<$Resolved[K], null>] extends [string] ? [string] extends [Exclude<$Resolved[K], null>] ? $Resolved[K] : Exclude<$Resolved[K], null> : $Resolved[K];
+} : never;
+export type TConflictKeys<R extends readonly PropertyKey[], O extends readonly PropertyKey[]> = Extract<R[number], O[number]>;
+type Normalize<T> = T extends object ? ((T extends {
+    select: infer S;
+} ? S : {}) & (T extends {
+    relations: infer R;
+} ? R : {}) & (T extends {
+    except: infer E;
+} ? {
+    _except: E;
+} : {}) & Omit<T, 'select' | 'relations' | 'except'>) : {};
+type IsStrict<T> = T extends true ? false : T extends object ? (T extends {
+    select: any;
+} ? true : T extends {
+    except: any;
+} ? false : (keyof Omit<T, 'relations' | 'except'> extends never ? false : true)) : false;
+type RemoveUndefined<T> = T extends undefined ? never : T;
+type NonObjectKeys<T> = {
+    [K in keyof T]: RemoveUndefined<T[K]> extends Date ? K : RemoveUndefined<T[K]> extends object ? never : K;
+}[keyof T];
+type GetExceptKeys<T> = T extends {
+    _except: infer E;
+} ? keyof E : never;
+export type TSelectionMerger<IncomingResult, S1, S2> = IncomingResult extends Date | Function ? IncomingResult : IncomingResult extends (infer U)[] ? TSelectionMerger<U, S1, S2>[] : IncomingResult extends object ? (Normalize<S1> extends infer F1 ? Normalize<S2> extends infer F2 ? (F1 & F2) extends infer Merged ? {
+    [K in keyof Omit<Merged, '_except'> & keyof IncomingResult]-?: TSelectionMerger<RemoveUndefined<IncomingResult[K]>, K extends keyof F1 ? F1[K] : unknown, K extends keyof F2 ? F2[K] : unknown>;
+} & ((IsStrict<S1> extends true ? true : IsStrict<S2> extends true ? true : false) extends true ? {} : {
+    [K in Exclude<NonObjectKeys<IncomingResult>, GetExceptKeys<F1> | GetExceptKeys<F2>>]-?: IncomingResult[K];
+}) : never : never : never) : IncomingResult;
+export type TStateWhereCondition = {
+    column?: string;
+    operator?: string;
+    value?: any;
+    condition?: 'AND' | 'OR';
+    nested?: TStateWhereCondition[];
+};
+export type TDefault<T = any> = (T extends string ? string : T extends number ? number : T extends boolean ? boolean | number : T) & {
+    __isDefault: true;
+};
+export type TRemoveDefault<T> = T extends TDefault<infer U> ? U : T;
+type CleanDefaultType<T> = T extends any ? NonNullable<T> extends Date ? T : NonNullable<T> extends Record<string, unknown> ? string : T extends {
+    __isDefault: true;
+} ? (T extends string ? string : T extends number ? number : boolean) | null : T : never;
+type IsOptional<T> = null extends T ? true : (T extends any ? (T extends {
+    __isDefault: true;
+} ? true : never) : never) extends never ? false : true;
+export type TInsertInput<K, C> = {
+    [P in Exclude<K & keyof C, "id" | "_id" | "uuid"> as IsOptional<C[P]> extends true ? never : P]: CleanDefaultType<C[P]>;
+} & {
+    [P in Exclude<K & keyof C, "id" | "_id" | "uuid"> as IsOptional<C[P]> extends true ? P : never]?: CleanDefaultType<C[P]>;
+} & {
+    [P in Extract<K & keyof C, "id" | "_id" | "uuid">]?: CleanDefaultType<C[P]>;
 };
+export type TUpdateInput<K, C> = {
+    [P in Exclude<K & keyof C, "id" | "_id">]: {
+        [Q in P]-?: CleanDefaultType<C[Q]>;
+    } & {
+        [Q in Exclude<K & keyof C, "id" | "_id" | P>]?: CleanDefaultType<C[Q]>;
+    };
+}[Exclude<K & keyof C, "id" | "_id">];
+export type TInsertOrUpdateInput<K, C> = {
+    [P in Extract<K, keyof C>]: {
+        [Q in P]-?: CleanDefaultType<C[Q]>;
+    } & {
+        [Q in Exclude<Extract<K, keyof C>, P>]?: CleanDefaultType<C[Q]>;
+    };
+}[Extract<K, keyof C>];
+export type TAction = "create" | "createMany" | "createNotExists" | "createOrSelect" | "createOrUpdate" | "update" | "updateMany" | null;
+export type TSaveBuilderResult<A extends TAction> = A extends "create" ? Record<string, any> : A extends "createMany" ? Record<string, any>[] : A extends "createNotExists" ? Record<string, any> | null : A extends "createOrUpdate" ? Record<string, any> : A extends "createOrSelect" ? Record<string, any> : A extends "update" ? Record<string, any> | null : A extends "updateMany" ? Record<string, any>[] : any;
+export type TSaveModelResult<M extends Model<any, any, any>, A extends TAction> = A extends "create" ? T.InsertResult<M> : A extends "createMany" ? T.InsertManyResult<M> : A extends "createNotExists" ? T.InsertResult<M> | null : A extends "createOrUpdate" ? T.InsertResult<M> | T.UpdateResult<M> : A extends "createOrSelect" ? T.InsertResult<M> | T.Result<M> : A extends "update" ? T.UpdateResult<M> : A extends "updateMany" ? T.UpdateManyResult<M> : T.InsertResult<M> | T.InsertManyResult<M> | T.UpdateResult<M> | T.UpdateManyResult<M> | T.Result<M>;
 export {};

package/dist/lib/types/repository/index.d.ts

@@ -2,41 +2,27 @@ import { Model } from "../../core/Model";
 import type { T } from "../../core";
 import type { TConnection, TConnectionTransaction, TNestedBoolean, TRawStringQuery, TRelationKeys, TSchemaKeys } from "..";
 import type { TColumnsDecorator, TRelationsDecorator } from "../decorator";
-export type TRepositorySelect<T = unknown, R = unknown, M extends Model = Model> = [
-    unknown,
-    unknown
-] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? TNestedBoolean : Partial<{
+export type TRepositorySelect<T = unknown, R = unknown, M extends Model = Model> = [unknown, unknown] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? TNestedBoolean : Partial<{
     [K in keyof TColumnsDecorator<M> | keyof TRelationsDecorator<M>]: K extends `${string}.${string}` | TRawStringQuery ? boolean : K extends keyof TRelationsDecorator<M> ? M[K] extends (infer U)[] ? U extends Model ? "*" | TRepositorySelect<any, unknown, U> : boolean : M[K] extends Model ? "*" | TRepositorySelect<any, unknown, M[K]> : boolean : K extends keyof TColumnsDecorator<M> ? boolean : boolean;
 }> : Partial<{
     [K in TSchemaKeys<T> | TRelationKeys<R>]: K extends TRelationKeys<R> ? K extends TRawStringQuery | `${string}.${string}` ? boolean : K extends `$${string & K}` ? R extends Record<string, any> ? boolean : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? "*" | TRepositorySelect<T.SchemaModel<U>, T.RelationModel<U>> : never : R[`$${K & string}`] extends Model ? "*" | TRepositorySelect<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>> : never : never : K extends keyof T ? boolean : never;
 }>;
-export type TRepositoryExcept<T = unknown, M extends Model = Model> = [
-    unknown
-] extends [T] ? keyof TColumnsDecorator<M> extends never ? TNestedBoolean : Partial<{
-    [K in keyof TColumnsDecorator<M>]: K extends `${string}.${string}` | TRawStringQuery ? boolean : K extends keyof TColumnsDecorator<M> ? boolean : never;
+export type TRepositoryExcept<T = unknown, R = unknown, M extends Model = Model> = [unknown, unknown] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? TNestedBoolean : Partial<{
+    [K in keyof TColumnsDecorator<M> | keyof TRelationsDecorator<M>]: K extends `${string}.${string}` | TRawStringQuery ? boolean : K extends keyof TRelationsDecorator<M> ? M[K] extends (infer U)[] ? U extends Model ? TRepositoryExcept<any, unknown, U> : boolean : M[K] extends Model ? TRepositoryExcept<any, unknown, M[K]> : boolean : K extends keyof TColumnsDecorator<M> ? boolean : boolean;
 }> : Partial<{
-    [K in TSchemaKeys<T>]: K extends keyof T ? boolean : never;
+    [K in TSchemaKeys<T> | TRelationKeys<R>]: K extends TRelationKeys<R> ? K extends TRawStringQuery | `${string}.${string}` ? boolean : K extends `$${string & K}` ? R extends Record<string, any> ? boolean : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? TRepositoryExcept<T.SchemaModel<U>, T.RelationModel<U>> : never : R[`$${K & string}`] extends Model ? TRepositoryExcept<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>> : never : never : K extends keyof T ? boolean : never;
 }>;
-export type TRepositoryWhere<T = unknown, R = unknown, M extends Model = Model> = [
-    unknown,
-    unknown
-] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, any> : Partial<{
+export type TRepositoryWhere<T = unknown, R = unknown, M extends Model = Model> = [unknown, unknown] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, any> : Partial<{
     [K in keyof TColumnsDecorator<M> | keyof TRelationsDecorator<M> | `${string}.${string}` | TRawStringQuery]: K extends keyof TRelationsDecorator<M> ? TRelationsDecorator<M>[K] extends (infer U)[] ? U extends Model ? TRepositoryWhere<any, unknown, U> | boolean : never : TRelationsDecorator<M>[K] extends Model ? TRepositoryWhere<any, unknown, TRelationsDecorator<M>[K]> | boolean : never : K extends keyof TColumnsDecorator<M> ? TColumnsDecorator<M>[K] : never;
 }> : Partial<{
     [K in TSchemaKeys<T> | TRelationKeys<R> | `${string}.${string}` | TRawStringQuery]: K extends TRelationKeys<R> ? K extends `$${string & K}` ? R extends Record<string, any> ? R[K] : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? TRepositoryWhere<T.SchemaModel<U>, T.RelationModel<U>, M> | boolean : never : R[`$${K & string}`] extends Model ? TRepositoryWhere<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>, M> | boolean : never : never : K extends keyof T ? T[K] : never;
 }>;
-export type TRepositoryOrderBy<T = unknown, R = unknown, M extends Model = Model> = [
-    unknown,
-    unknown
-] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, "ASC" | "DESC"> : Partial<{
+export type TRepositoryOrderBy<T = unknown, R = unknown, M extends Model = Model> = [unknown, unknown] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, "ASC" | "DESC"> : Partial<{
     [K in keyof TColumnsDecorator<M> | keyof TRelationsDecorator<M>]: K extends `${string}.${string}` | TRawStringQuery ? "ASC" | "DESC" : K extends keyof TRelationsDecorator<M> ? M[K] extends (infer U)[] ? U extends Model ? TRepositoryOrderBy<any, unknown, U> : never : M[K] extends Model ? TRepositoryOrderBy<any, unknown, M[K]> : never : K extends keyof TColumnsDecorator<M> ? "ASC" | "DESC" : never;
 }> : Partial<{
     [K in TSchemaKeys<T> | TRelationKeys<R>]: K extends TRelationKeys<R> ? K extends TRawStringQuery | `${string}.${string}` ? "ASC" | "DESC" : K extends `$${string & K}` ? R extends Record<string, any> ? "ASC" | "DESC" : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? TRepositoryOrderBy<T.SchemaModel<U>, T.RelationModel<U>> : never : R[`$${K & string}`] extends Model ? TRepositoryOrderBy<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>> : never : never : K extends keyof T ? "ASC" | "DESC" : never;
 }>;
-export type TRepositoryGroupBy<T = unknown, R = unknown, M extends Model = Model> = [
-    unknown,
-    unknown
-] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, boolean> : Partial<{
+export type TRepositoryGroupBy<T = unknown, R = unknown, M extends Model = Model> = [unknown, unknown] extends [T, R] ? keyof TColumnsDecorator<M> extends never ? Record<string, boolean> : Partial<{
     [K in keyof TColumnsDecorator<M> | keyof TRelationsDecorator<M>]: K extends `${string}.${string}` | TRawStringQuery ? boolean : K extends keyof TRelationsDecorator<M> ? M[K] extends (infer U)[] ? U extends Model ? "*" | TRepositoryGroupBy<any, unknown, U> : boolean : M[K] extends Model ? "*" | TRepositoryGroupBy<any, unknown, M[K]> : boolean : K extends keyof TColumnsDecorator<M> ? boolean : boolean;
 }> : Partial<{
     [K in TSchemaKeys<T> | TRelationKeys<R>]: K extends TRelationKeys<R> ? K extends TRawStringQuery | `${string}.${string}` ? boolean : K extends `$${string & K}` ? R extends Record<string, any> ? boolean : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? "*" | TRepositoryGroupBy<T.SchemaModel<U>, T.RelationModel<U>> : never : R[`$${K & string}`] extends Model ? "*" | TRepositoryGroupBy<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>> : never : never : K extends keyof T ? boolean : never;
@@ -48,13 +34,25 @@ export type TRepositoryRelation<R = unknown, M extends Model = Model> = [
 }> : Partial<{
     [K in TRelationKeys<R>]: K extends TRelationKeys<R> ? K extends `$${string & K}` ? R extends Record<string, any> ? boolean : never : R extends Record<string, any> ? R[`$${string & K}`] extends (infer U)[] ? U extends Model ? boolean | (TRepositoryRequest<T.SchemaModel<U>, T.RelationModel<U>> & TRepositoryRelation<T.RelationModel<U>>) : never : R[`$${K & string}`] extends Model ? boolean | (TRepositoryRequest<T.SchemaModel<R[`$${K & string}`]>, T.RelationModel<R[`$${K & string}`]>> & TRepositoryRelation<T.RelationModel<R[`$${K & string}`]>>) : never : never : never;
 }>;
-export type TRepositoryRequest<T = unknown, R = unknown, M extends Model<any, any> = Model<any, any>, S = undefined, SR = undefined, E = undefined> = {
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type XOR<T, U> = (T & Without<U, T>) | (U & Without<T, U>);
+type SelectBlock<T, R, M extends Model<any, any>, S> = {
     select?: S extends {} ? S & {
         [K in keyof S]: K extends keyof TRepositorySelect<T, R, M> ? S[K] : never;
     } : "*" | TRepositorySelect<T, R, M>;
+};
+type ExceptBlock<T, R, M extends Model<any, any>, E> = {
     except?: E extends {} ? E & {
-        [K in keyof E]: K extends keyof TRepositoryExcept<T, M> ? E[K] : never;
-    } : TRepositoryExcept<T, M>;
+        [K in keyof E]: K extends keyof TRepositoryExcept<T, R, M> ? E[K] : never;
+    } : TRepositoryExcept<T, R, M>;
+};
+export type TRepositoryRequest<T = unknown, R = unknown, M extends Model<any, any> = Model<any, any>, S = undefined, SR = undefined, E = undefined, SRS = undefined, G = undefined> = XOR<SelectBlock<T, R, M, S>, // select ?:
+ExceptBlock<T, R, M, E>> & {
+    selectRaw?: SRS extends {} ? SRS & {
+        [K in keyof SRS]: SRS[K] extends TRawStringQuery ? SRS[K] : never;
+    } : Record<string, TRawStringQuery>;
     join?: {
         localKey: `${string}.${string}`;
         referenceKey: `${string}.${string}`;
@@ -75,23 +73,31 @@ export type TRepositoryRequest<T = unknown, R = unknown, M extends Model<any, an
     orderBy?: TRepositoryOrderBy<T, R, M>;
     limit?: number;
     offset?: number;
+    extend?: G extends {} ? G & {
+        [K in keyof G]: G[K];
+    } : Record<string, T.RepositoryGenericTypeOptions>;
     debug?: boolean;
     cache?: {
         key: string;
         expires: number;
+        namespace?: boolean;
     };
     when?: {
         condition: boolean;
         query: () => TRepositoryRequest<T, R, M, S, SR>;
     };
-    relations?: SR extends {} ? SR : TRepositoryRelation<R, M>;
-    relationsExists?: SR extends {} ? SR : TRepositoryRelation<R, M>;
     using?: (model: M) => M;
     hooks?: Function[];
     audit?: {
         userId: number;
         metadata?: Record<string, any>;
     };
+    relations?: SR extends {} ? SR & {
+        [K in keyof SR]: K extends keyof TRepositoryRelation<R, M> ? SR[K] : never;
+    } : TRepositoryRelation<R, M>;
+    relationsExists?: SR extends {} ? SR & {
+        [K in keyof SR]: K extends keyof TRepositoryRelation<R, M> ? SR[K] : never;
+    } : TRepositoryRelation<R, M>;
 };
 export type TRepositoryRequestHandler<T extends Record<string, any> = any, R = unknown, M extends Model<any, any> = Model<any, any>> = Partial<TRepositoryRequest<T, R, M> & {
     instance?: Model;
@@ -100,37 +106,62 @@ export type TRepositoryRequestPagination<T extends Record<string, any> = any, R
     page?: number;
 };
 export type TRepositoryRequestAggregate<T extends Record<string, any> = any, R = any, M extends Model<any, any> = Model<any, any>> = Partial<Omit<TRepositoryRequest<T, R, M>, "relations" | "relationQuery">>;
-export type TRepositoryCreate<M extends Model<any, any> = Model<any, any>> = {
-    data: Partial<T.ColumnOptions<M>>;
+export type TRepositoryCreate<M extends Model<any, any> = Model<any, any>, NR extends boolean | undefined = false, K extends T.ColumnKeys<M> = T.ColumnKeys<M>, C extends T.ColumnOptions<M> = T.ColumnOptions<M>> = {
+    data: {
+        [P in Exclude<K & keyof C, "id" | "uuid"> as null extends C[P] ? any : P]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+    };
     debug?: boolean;
     transaction?: TConnection | TConnectionTransaction;
+    noReturn?: NR;
 };
-export type TRepositoryCreateMultiple<M extends Model<any, any> = Model<any, any>> = {
-    data: Partial<T.ColumnOptions<M>>[];
+export type TRepositoryCreateMultiple<M extends Model<any, any> = Model<any, any>, NR extends boolean | undefined = false, K extends T.ColumnKeys<M> = T.ColumnKeys<M>, C extends T.ColumnOptions<M> = T.ColumnOptions<M>> = {
+    data: {
+        [P in Exclude<K & keyof C, "id" | "uuid"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+    }[];
     debug?: boolean;
     transaction?: TConnection | TConnectionTransaction;
+    noReturn?: NR;
 };
-export type TRepositoryCreateOrThings<M extends Model<any, any> = Model<any, any>> = {
-    data: Partial<T.ColumnOptions<M>>;
+export type TRepositoryCreateOrThings<M extends Model<any, any> = Model<any, any>, NR extends boolean | undefined = false, K extends T.ColumnKeys<M> = T.ColumnKeys<M>, C extends T.ColumnOptions<M> = T.ColumnOptions<M>> = {
+    data: {
+        [P in Exclude<K & keyof C, "id" | "uuid"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+    };
     where: T.WhereOptions<M>;
     debug?: boolean;
+    transaction?: TConnection | TConnectionTransaction;
+    noReturn?: NR;
 };
-export type TRepositoryUpdate<M extends Model<any, any> = Model<any, any>> = {
-    data: Partial<T.ColumnOptions<M>>;
+export type TRepositoryUpdate<M extends Model<any, any> = Model<any, any>, NR extends boolean | undefined = false, K extends T.ColumnKeys<M> = T.ColumnKeys<M>, C extends T.ColumnOptions<M> = T.ColumnOptions<M>> = {
+    data: Partial<{
+        [P in K & keyof C]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+    }>;
     where: T.WhereOptions<M>;
     debug?: boolean;
     transaction?: TConnection | TConnectionTransaction;
+    noReturn?: NR;
 };
-export type TRepositoryUpdateMultiple<M extends Model<any, any> = Model<any, any>> = {
+export type TRepositoryUpdateMultiple<M extends Model<any, any> = Model<any, any>, NR extends boolean | undefined = false, K extends T.ColumnKeys<M> = T.ColumnKeys<M>, C extends T.ColumnOptions<M> = T.ColumnOptions<M>> = {
     cases: {
-        condition: ((query: M) => M) | Partial<T.ColumnOptions<M>>;
-        columns: Partial<T.ColumnOptions<M>>;
+        condition: ((query: M) => M) | Partial<{
+            [P in K & keyof C]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+        }>;
+        columns: Partial<{
+            [P in K & keyof C]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : any;
+        }>;
     }[];
     debug?: boolean;
     transaction?: TConnection | TConnectionTransaction;
+    noReturn?: NR;
 };
 export type TRepositoryDelete<M extends Model<any, any> = Model<any, any>> = {
     where: T.WhereOptions<M>;
     debug?: boolean;
     transaction?: TConnection | TConnectionTransaction;
 };
+export type TRepositoryPrimitiveExtendType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends readonly (infer U)[] ? TRepositoryPrimitiveExtendType<U>[] : T extends Record<string, any> ? {
+    [K in keyof T]: TRepositoryPrimitiveExtendType<T[K]>;
+} : T;
+export type TRepositoryExtendType = NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | readonly TRepositoryExtendType[] | {
+    [_: string]: TRepositoryExtendType;
+};
+export {};

package/dist/lib/utils/index.d.ts

@@ -1,9 +1,10 @@
+import { TStateWhereCondition } from "../types";
 declare const utils: {
     typeOf: (data: any) => string;
     isDate: (data: any) => boolean;
     consoleDebug: (sql?: string, retry?: boolean) => void;
     consoleExec: (startTime: number, endTime: number) => void;
-    consoleCache: (provider: string) => void;
+    consoleCache: (provider: Record<string, any>) => void;
     faker: (value: string) => string | number | boolean;
     columnRelation: (name: string) => string;
     timestamp: (dateString?: string | Date) => string;
@@ -27,7 +28,7 @@ declare const utils: {
         value: string;
     } | null;
     checkValueHasRaw: (value: unknown) => boolean;
-    valueAndOperator: (value: string, operator: string, useDefault?: boolean) => any[];
+    valueAndOperator: (value: any, operator: string, useDefault?: boolean) => any[];
     baseModelTemplate: ({ model, schema, imports, relation }: {
         model: string;
         schema: string;
@@ -50,6 +51,16 @@ declare const utils: {
         }> | null;
         action: "to" | "from";
     }) => Promise<void>;
+    hash32: (str: string) => number;
+    nestConditions: (conditions: TStateWhereCondition[], condition?: "AND" | "OR") => {
+        condition: "AND" | "OR";
+        nested: TStateWhereCondition[] | undefined;
+        column?: string;
+        operator?: string;
+        value?: any;
+    }[];
+    formatQueryValue: (v: any) => any;
+    bindingParameters: (sql: string, parameters?: (boolean | number | string | any[] | null)[]) => string;
 };
 export type TUtils = typeof utils;
 export { utils };

package/dist/lib/utils/index.js

@@ -217,7 +217,34 @@ const consoleExec = (startTime, endTime) => {
     console.log(`\x1b[34mDURATION:\x1b[0m \x1b[32m${diffInSeconds} sec\x1b[0m`);
 };
 const consoleCache = (provider) => {
-    console.log(`\n\x1b[34mCACHE:\x1b[0m \x1b[33m${provider}\x1b[0m`);
+    const colors = {
+        reset: "\x1b[0m",
+        key: "\x1b[35m",
+        string: "\x1b[38;2;77;215;240m",
+        null: "\x1b[90m",
+    };
+    const colorize = (raws) => {
+        const obj = Object.fromEntries(Object.entries(raws)
+            .filter(([_, v]) => v !== undefined));
+        const parts = Object.entries(obj).map(([k, v]) => {
+            let valueColor = colors.reset;
+            let value;
+            if (typeof v === "string") {
+                valueColor = colors.string;
+                value = `"${v}"`;
+            }
+            else if (v === null) {
+                valueColor = colors.null;
+                value = "null";
+            }
+            else {
+                value = JSON.stringify(v);
+            }
+            return `${colors.key}"${k}"${colors.reset}: ${valueColor}${value}${colors.reset}`;
+        });
+        return `{ ${parts.join(", ")} }`;
+    };
+    console.log(`\n\x1b[34mCACHE:\x1b[0m ${colorize(provider)}`);
 };
 const randomString = (length = 100) => {
     let str = '';
@@ -398,6 +425,54 @@ const applyTransforms = async ({ result, transforms, action }) => {
     }
     return;
 };
+const hash32 = (str) => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+};
+const nestConditions = (conditions, condition = 'AND') => {
+    if (!conditions || conditions.length === 0)
+        return [];
+    const [first, ...rest] = conditions;
+    return [{
+            ...first,
+            condition,
+            nested: rest.length > 0 ? rest : undefined
+        }];
+};
+const formatQueryValue = (v) => {
+    if (Array.isArray(v)) {
+        const formated = [];
+        for (const val of v) {
+            formated.push(formatQueryValue(val));
+        }
+        return formated;
+    }
+    v = transfromDateToDateString(v);
+    v = escape(v);
+    v = transfromBooleanToNumber(v);
+    return transfromValueHasRaw(v);
+};
+const bindingParameters = (sql, parameters = []) => {
+    let bindSql = sql;
+    for (const parameter of parameters) {
+        if (parameter === null) {
+            bindSql = bindSql.replace("?", constants_1.CONSTANTS.NULL);
+            continue;
+        }
+        if (parameter === true || parameter === false) {
+            bindSql = bindSql.replace("?", `'${parameter === true ? 1 : 0}'`);
+            continue;
+        }
+        bindSql = bindSql.replace("?", Array.isArray(parameter)
+            ? `(${parameter.map((p) => p).join(",")})`
+            : `${parameter}`);
+    }
+    return bindSql;
+};
 const utils = {
     typeOf,
     isDate,
@@ -427,7 +502,11 @@ const utils = {
     valueAndOperator,
     baseModelTemplate,
     decoratorModelTemplate,
-    applyTransforms
+    applyTransforms,
+    hash32,
+    nestConditions,
+    formatQueryValue,
+    bindingParameters
 };
 exports.utils = utils;
 exports.default = utils;