@node-c/persistance-rdb 1.0.0-alpha4 → 1.0.0-alpha40

package/dist/index.js

@@ -15,8 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./common/definitions"), exports);
-__exportStar(require("./entityService"), exports);
-__exportStar(require("./module"), exports);
+__exportStar(require("./entity"), exports);
+__exportStar(require("./ormQueryBuilder"), exports);
 __exportStar(require("./repository"), exports);
 __exportStar(require("./sqlQueryBuilder"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,kDAAgC;AAChC,2CAAyB;AACzB,+CAA6B;AAC7B,oDAAkC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,2CAAyB;AACzB,oDAAkC;AAClC,+CAA6B;AAC7B,oDAAkC"}

package/dist/ormQueryBuilder/index.d.ts

@@ -0,0 +1 @@
+export * from './rdb.ormQueryBuilder';

package/dist/{module → ormQueryBuilder}/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./rdb.module.definitions"), exports);
-__exportStar(require("./rdb.module"), exports);
+__exportStar(require("./rdb.ormQueryBuilder"), exports);
 //# sourceMappingURL=index.js.map

package/dist/ormQueryBuilder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ormQueryBuilder/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC"}

package/dist/ormQueryBuilder/rdb.ormQueryBuilder.d.ts

@@ -0,0 +1,38 @@
+import { PersistanceOrderByDirection } from '@node-c/core';
+export declare abstract class OrmBaseQueryBuilder<Entity> {
+    abstract andWhere(..._args: unknown[]): OrmBaseQueryBuilder<Entity>;
+    abstract orWhere(..._args: unknown[]): OrmBaseQueryBuilder<Entity>;
+    abstract where(..._args: unknown[]): OrmBaseQueryBuilder<Entity>;
+}
+export declare abstract class OrmDeleteQueryBuilder<Entity> extends OrmBaseQueryBuilder<Entity> {
+    abstract execute(): Promise<OrmDeleteQueryBuilderDeleteResult>;
+}
+export interface OrmDeleteQueryBuilderDeleteResult {
+    affected?: number | null;
+    raw: unknown;
+}
+export declare abstract class OrmSelectQueryBuilder<Entity> extends OrmBaseQueryBuilder<Entity> {
+    abstract addOrderBy(_field: string, _direction: PersistanceOrderByDirection): OrmSelectQueryBuilder<Entity>;
+    abstract delete(): OrmDeleteQueryBuilder<Entity>;
+    abstract getCount(): Promise<number>;
+    abstract getMany(): Promise<Entity[]>;
+    abstract getOne(): Promise<Entity | null>;
+    abstract leftJoinAndSelect(..._args: unknown[]): OrmSelectQueryBuilder<Entity>;
+    abstract orderBy(_field: string, _direction: PersistanceOrderByDirection): OrmSelectQueryBuilder<Entity>;
+    abstract select(_selection: string[]): OrmSelectQueryBuilder<Entity>;
+    abstract skip(_skipCount: number): OrmSelectQueryBuilder<Entity>;
+    abstract softDelete(): OrmDeleteQueryBuilder<Entity>;
+    abstract take(_takeCount: number): OrmSelectQueryBuilder<Entity>;
+    abstract update(): OrmUpdateQueryBuilder<Entity>;
+    abstract withDeleted(): OrmSelectQueryBuilder<Entity>;
+}
+export declare abstract class OrmUpdateQueryBuilder<Entity> extends OrmBaseQueryBuilder<Entity> {
+    abstract execute(): Promise<OrmUpdateQueryBuilderUpdateResult>;
+    abstract returning(_selection: string | string[]): OrmUpdateQueryBuilder<Entity>;
+    abstract set(..._args: unknown[]): OrmUpdateQueryBuilder<Entity>;
+}
+export interface OrmUpdateQueryBuilderUpdateResult {
+    affected?: number;
+    generatedMaps?: object[];
+    raw: unknown;
+}

package/dist/ormQueryBuilder/rdb.ormQueryBuilder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrmUpdateQueryBuilder = exports.OrmSelectQueryBuilder = exports.OrmDeleteQueryBuilder = exports.OrmBaseQueryBuilder = void 0;
+class OrmBaseQueryBuilder {
+}
+exports.OrmBaseQueryBuilder = OrmBaseQueryBuilder;
+class OrmDeleteQueryBuilder extends OrmBaseQueryBuilder {
+}
+exports.OrmDeleteQueryBuilder = OrmDeleteQueryBuilder;
+class OrmSelectQueryBuilder extends OrmBaseQueryBuilder {
+}
+exports.OrmSelectQueryBuilder = OrmSelectQueryBuilder;
+class OrmUpdateQueryBuilder extends OrmBaseQueryBuilder {
+}
+exports.OrmUpdateQueryBuilder = OrmUpdateQueryBuilder;
+//# sourceMappingURL=rdb.ormQueryBuilder.js.map

package/dist/ormQueryBuilder/rdb.ormQueryBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rdb.ormQueryBuilder.js","sourceRoot":"","sources":["../../src/ormQueryBuilder/rdb.ormQueryBuilder.ts"],"names":[],"mappings":";;;AAEA,MAAsB,mBAAmB;CAIxC;AAJD,kDAIC;AAED,MAAsB,qBAA8B,SAAQ,mBAA2B;CAEtF;AAFD,sDAEC;AAOD,MAAsB,qBAA8B,SAAQ,mBAA2B;CActF;AAdD,sDAcC;AAED,MAAsB,qBAA8B,SAAQ,mBAA2B;CAItF;AAJD,sDAIC"}

package/dist/repository/index.d.ts

@@ -1,2 +1 @@
-export * from './rdb.repository.definitions';
-export * from './rdb.repository.module';
+export * from './rdb.repository';

package/dist/repository/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./rdb.repository.definitions"), exports);
-__exportStar(require("./rdb.repository.module"), exports);
+__exportStar(require("./rdb.repository"), exports);
 //# sourceMappingURL=index.js.map

package/dist/repository/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/repository/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AACA,+DAA6C;AAC7C,0DAAwC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/repository/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAiC"}

package/dist/repository/rdb.repository.d.ts

@@ -1,7 +1,22 @@
-import { EntityClassOrSchema } from '@nestjs/typeorm/dist/interfaces/entity-class-or-schema.type';
-import { DataSource, ObjectLiteral, Repository } from 'typeorm';
-export declare class RDBRepository<Entity extends ObjectLiteral> extends Repository<Entity> {
-    protected entityClass: EntityClassOrSchema;
-    protected dataSource: DataSource;
-    constructor(entityClass: EntityClassOrSchema, dataSource: DataSource);
+import { GenericObject, GenericObjectType } from '@node-c/core';
+import { OrmSelectQueryBuilder } from '../ormQueryBuilder';
+export declare abstract class RDBEntityManager {
+    abstract getRepository<Entity extends GenericObject<unknown>>(_target: unknown): RDBRepository<Entity>;
+    abstract query(_query: string, _params?: unknown[]): Promise<unknown>;
+    abstract save<Entity extends GenericObject<unknown> = GenericObject<unknown>>(_target: unknown, _data: Partial<Entity> | Partial<Entity[]>, _options?: unknown): Promise<unknown>;
+    abstract transaction(_callback: (_em: RDBEntityManager) => Promise<unknown>): Promise<unknown>;
+}
+export type RDBEntityTarget<Entity> = string | {
+    name: string;
+    type: Entity;
+} | GenericObjectType<Entity>;
+export declare abstract class RDBRepository<Entity extends GenericObject<unknown>> {
+    manager: RDBEntityManager;
+    metadata: {
+        name: string;
+        tableName: string;
+    };
+    target: unknown;
+    abstract createQueryBuilder(_entityName: string, _queryRunner?: unknown): OrmSelectQueryBuilder<Entity>;
+    abstract save(_data: Partial<Entity> | Partial<Entity[]>, _options?: unknown): Promise<unknown>;
 }

package/dist/repository/rdb.repository.js

@@ -1,31 +1,10 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RDBRepository = void 0;
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("typeorm");
-let RDBRepository = class RDBRepository extends typeorm_1.Repository {
-    constructor(entityClass, dataSource) {
-        super(entityClass, dataSource.createEntityManager());
-        this.entityClass = entityClass;
-        this.dataSource = dataSource;
-    }
-};
+exports.RDBRepository = exports.RDBEntityManager = void 0;
+class RDBEntityManager {
+}
+exports.RDBEntityManager = RDBEntityManager;
+class RDBRepository {
+}
 exports.RDBRepository = RDBRepository;
-exports.RDBRepository = RDBRepository = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)('RDB_REPOSITORY_ENTITY_CLASS')),
-    __metadata("design:paramtypes", [Object, typeorm_1.DataSource])
-], RDBRepository);
 //# sourceMappingURL=rdb.repository.js.map

package/dist/repository/rdb.repository.js.map

@@ -1 +1 @@
-{"version":3,"file":"rdb.repository.js","sourceRoot":"","sources":["../../src/repository/rdb.repository.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAAoD;AAGpD,qCAAgE;AAGzD,IAAM,aAAa,GAAnB,MAAM,aAA4C,SAAQ,oBAAkB;IACjF,YAEY,WAAgC,EAEhC,UAAsB;QAEhC,KAAK,CAAC,WAAW,EAAE,UAAU,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAJ3C,gBAAW,GAAX,WAAW,CAAqB;QAEhC,eAAU,GAAV,UAAU,CAAY;IAGlC,CAAC;CACF,CAAA;AATY,sCAAa;wBAAb,aAAa;IADzB,IAAA,mBAAU,GAAE;IAGR,WAAA,IAAA,eAAM,EAAC,6BAA6B,CAAC,CAAA;6CAGhB,oBAAU;GALvB,aAAa,CASzB"}
+{"version":3,"file":"rdb.repository.js","sourceRoot":"","sources":["../../src/repository/rdb.repository.ts"],"names":[],"mappings":";;;AAIA,MAAsB,gBAAgB;CASrC;AATD,4CASC;AAID,MAAsB,aAAa;CAUlC;AAVD,sCAUC"}

package/dist/sqlQueryBuilder/index.d.ts

@@ -1,3 +1,3 @@
-export * from './sqlQueryBuilder.definitions';
-export * from './sqlQueryBuilder.module';
-export * from './sqlQueryBuilder.service';
+export * from './rdb.sqlQueryBuilder.definitions';
+export * from './rdb.sqlQueryBuilder.module';
+export * from './rdb.sqlQueryBuilder.service';

package/dist/sqlQueryBuilder/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./sqlQueryBuilder.definitions"), exports);
-__exportStar(require("./sqlQueryBuilder.module"), exports);
-__exportStar(require("./sqlQueryBuilder.service"), exports);
+__exportStar(require("./rdb.sqlQueryBuilder.definitions"), exports);
+__exportStar(require("./rdb.sqlQueryBuilder.module"), exports);
+__exportStar(require("./rdb.sqlQueryBuilder.service"), exports);
 //# sourceMappingURL=index.js.map

package/dist/sqlQueryBuilder/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sqlQueryBuilder/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gEAA8C;AAC9C,2DAAyC;AACzC,4DAA0C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sqlQueryBuilder/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oEAAkD;AAClD,+DAA6C;AAC7C,gEAA8C"}

package/dist/sqlQueryBuilder/{sqlQueryBuilder.definitions.d.ts → rdb.sqlQueryBuilder.definitions.d.ts}

@@ -1,8 +1,8 @@
-import { GenericObject } from '@node-c/core';
+import { GenericObject, PersistanceOrderBy } from '@node-c/core';
 export interface BuildQueryOptions {
     deletedColumnName?: string;
     include?: IncludeItems;
-    orderBy?: OrderBy[];
+    orderBy?: PersistanceOrderBy[];
     select?: string[];
     where?: {
         [fieldName: string]: ParsedFilter;
@@ -12,10 +12,6 @@ export interface BuildQueryOptions {
 export interface IncludeItems {
     [relationProperty: string]: string;
 }
-export interface OrderBy {
-    field: string;
-    direction: 'ASC' | 'DESC';
-}
 export interface ParsedFilter {
     params?: GenericObject<unknown>;
     query: string;

package/dist/{repository/rdb.repository.definitions.js → sqlQueryBuilder/rdb.sqlQueryBuilder.definitions.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=rdb.repository.definitions.js.map
+//# sourceMappingURL=rdb.sqlQueryBuilder.definitions.js.map

package/dist/sqlQueryBuilder/rdb.sqlQueryBuilder.definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rdb.sqlQueryBuilder.definitions.js","sourceRoot":"","sources":["../../src/sqlQueryBuilder/rdb.sqlQueryBuilder.definitions.ts"],"names":[],"mappings":""}

package/dist/sqlQueryBuilder/{sqlQueryBuilder.module.d.ts → rdb.sqlQueryBuilder.module.d.ts}

@@ -1,5 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
-import { SQLQueryBuilderModuleOptions } from './sqlQueryBuilder.definitions';
+import { SQLQueryBuilderModuleOptions } from './rdb.sqlQueryBuilder.definitions';
 export declare class SQLQueryBuilderModule {
     static register(options: SQLQueryBuilderModuleOptions): DynamicModule;
 }

package/dist/sqlQueryBuilder/{sqlQueryBuilder.module.js → rdb.sqlQueryBuilder.module.js}

@@ -9,7 +9,8 @@ var SQLQueryBuilderModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLQueryBuilderModule = void 0;
 const common_1 = require("@nestjs/common");
-const sqlQueryBuilder_service_1 = require("./sqlQueryBuilder.service");
+const core_1 = require("@node-c/core");
+const rdb_sqlQueryBuilder_service_1 = require("./rdb.sqlQueryBuilder.service");
 const definitions_1 = require("../common/definitions");
 let SQLQueryBuilderModule = SQLQueryBuilderModule_1 = class SQLQueryBuilderModule {
     static register(options) {
@@ -23,9 +24,13 @@ let SQLQueryBuilderModule = SQLQueryBuilderModule_1 = class SQLQueryBuilderModul
                     provide: definitions_1.Constants.SQL_BUILDER_DB_CONFIG_PATH,
                     useValue: `config.persistance.${persistanceModuleName}`
                 },
-                { provide: serviceToken, useClass: sqlQueryBuilder_service_1.SQLQueryBuilderService }
+                {
+                    provide: core_1.Constants.PERSISTANCE_MODULE_NAME,
+                    useValue: persistanceModuleName
+                },
+                { provide: serviceToken, useClass: rdb_sqlQueryBuilder_service_1.SQLQueryBuilderService }
             ],
-            exports: [{ provide: serviceToken, useClass: sqlQueryBuilder_service_1.SQLQueryBuilderService }]
+            exports: [{ provide: serviceToken, useClass: rdb_sqlQueryBuilder_service_1.SQLQueryBuilderService }]
         };
     }
 };
@@ -33,4 +38,4 @@ exports.SQLQueryBuilderModule = SQLQueryBuilderModule;
 exports.SQLQueryBuilderModule = SQLQueryBuilderModule = SQLQueryBuilderModule_1 = __decorate([
     (0, common_1.Module)({})
 ], SQLQueryBuilderModule);
-//# sourceMappingURL=sqlQueryBuilder.module.js.map
+//# sourceMappingURL=rdb.sqlQueryBuilder.module.js.map

package/dist/sqlQueryBuilder/rdb.sqlQueryBuilder.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rdb.sqlQueryBuilder.module.js","sourceRoot":"","sources":["../../src/sqlQueryBuilder/rdb.sqlQueryBuilder.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAuD;AAEvD,uCAA0D;AAG1D,+EAAuE;AAEvE,uDAAkD;AAG3C,IAAM,qBAAqB,6BAA3B,MAAM,qBAAqB;IAChC,MAAM,CAAC,QAAQ,CAAC,OAAqC;QACnD,MAAM,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC;QAC1C,MAAM,YAAY,GAAG,GAAG,qBAAqB,GAAG,uBAAS,CAAC,gCAAgC,EAAE,CAAC;QAC7F,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,uBAAqB;YAC7B,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,uBAAS,CAAC,0BAA0B;oBAC7C,QAAQ,EAAE,sBAAsB,qBAAqB,EAAE;iBACxD;gBACD;oBACE,OAAO,EAAE,gBAAa,CAAC,uBAAuB;oBAC9C,QAAQ,EAAE,qBAAqB;iBAChC;gBACD,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,oDAAsB,EAAE;aAC5D;YACD,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,oDAAsB,EAAE,CAAC;SACvE,CAAC;IACJ,CAAC;CACF,CAAA;AArBY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,qBAAqB,CAqBjC"}

package/dist/sqlQueryBuilder/rdb.sqlQueryBuilder.service.d.ts

@@ -0,0 +1,47 @@
+import { ConfigProviderService, GenericObject, PersistanceOrderBy, PersistanceOrderByDirection, PersistanceSelectOperator, RDBType } from '@node-c/core';
+import { BuildQueryOptions, IncludeItems, ParsedFilter } from './rdb.sqlQueryBuilder.definitions';
+import { OrmBaseQueryBuilder, OrmSelectQueryBuilder } from '../ormQueryBuilder';
+export declare class SQLQueryBuilderService {
+    configProvider: ConfigProviderService;
+    dbConfigPath: string;
+    persistanceModuleName: string;
+    allowedStringOperators: string[];
+    columnQuotesSymbol: string;
+    dbType: RDBType | string;
+    iLikeSupported: boolean;
+    returningSupported: boolean;
+    constructor(configProvider: ConfigProviderService, dbConfigPath: string, persistanceModuleName: string);
+    buildQuery<Entity>(ormQueryBuilder: OrmBaseQueryBuilder<Entity> | OrmSelectQueryBuilder<Entity>, options: BuildQueryOptions): void;
+    protected getValueForFilter(entityName: string, _fieldName: string, fieldAlias: string, fieldValue: unknown, isNot: boolean, operator?: PersistanceSelectOperator): ParsedFilter;
+    protected parseArrayOfFilters(filtersArray: unknown[], fieldAlias: string): {
+        hasValues: boolean;
+        isSimple: boolean;
+        paramsForQuery: GenericObject;
+        queryTemplateParamNames: string;
+    };
+    parseFilters(entityName: string, filters: GenericObject, options?: {
+        fieldAliases?: {
+            [fieldName: string]: string;
+        };
+        isTopLevel?: boolean;
+        operator?: PersistanceSelectOperator;
+        parameterNamesToFieldAliasesMap?: {
+            [fieldName: string]: string;
+        };
+    }): {
+        where: {
+            [fieldName: string]: ParsedFilter;
+        };
+        include: IncludeItems;
+    };
+    protected parseInnerFilters(entityName: string, filtersObject: GenericObject, fieldName: string, fieldAlias: string, operator?: PersistanceSelectOperator): {
+        parsedFilter: ParsedFilter;
+        include: IncludeItems;
+    };
+    parseRelations(entityName: string, include: string[], currentInclude?: IncludeItems): IncludeItems;
+    parseOrderBy(entityName: string, orderByData: GenericObject<PersistanceOrderByDirection>): {
+        include: IncludeItems;
+        orderBy: PersistanceOrderBy[];
+    };
+    parseSelect(selectFields: string[], include?: IncludeItems): string[];
+}

package/dist/sqlQueryBuilder/{sqlQueryBuilder.service.js → rdb.sqlQueryBuilder.service.js}

@@ -11,52 +11,64 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLQueryBuilderService = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@node-c/core");
-const general_tools_1 = require("@ramster/general-tools");
-const typeorm_1 = require("typeorm");
+const lodash_1 = __importDefault(require("lodash"));
 const definitions_1 = require("../common/definitions");
 let SQLQueryBuilderService = class SQLQueryBuilderService {
-    constructor(configProvider, dbConfigPath) {
+    constructor(configProvider, dbConfigPath, persistanceModuleName) {
         this.configProvider = configProvider;
         this.dbConfigPath = dbConfigPath;
+        this.persistanceModuleName = persistanceModuleName;
         this.allowedStringOperators = Object.values(core_1.PersistanceSelectOperator);
-        const { type } = (0, general_tools_1.getNested)(configProvider, dbConfigPath);
+        const { type } = lodash_1.default.get(configProvider, dbConfigPath);
         this.dbType = type;
-        if (type === core_1.RDBType.MySQL) {
+        if (type === core_1.RDBType.Aurora || type === core_1.RDBType.ClickHouse || type === core_1.RDBType.MySQL) {
             this.columnQuotesSymbol = '`';
             this.iLikeSupported = false;
+            this.returningSupported = false;
         }
         else if (type === core_1.RDBType.PG) {
             this.columnQuotesSymbol = '"';
             this.iLikeSupported = true;
+            this.returningSupported = true;
         }
     }
-    buildQuery(queryBuilder, options) {
-        const { where, include, orderBy, select, withDeleted = false } = options;
+    buildQuery(ormQueryBuilder, options) {
+        const { where: optWhere, include, orderBy, select, withDeleted } = options;
         const cqs = this.columnQuotesSymbol;
         const deletedColumnName = options.deletedColumnName || 'deletedAt';
-        if (queryBuilder instanceof typeorm_1.SelectQueryBuilder) {
+        const where = Object.assign({}, (optWhere || {}));
+        if ('withDeleted' in ormQueryBuilder) {
+            const oqb = ormQueryBuilder;
             if (withDeleted) {
-                queryBuilder.withDeleted();
+                oqb.withDeleted();
             }
             if (include) {
                 for (const relationProperty in include) {
                     if (withDeleted) {
-                        queryBuilder.leftJoinAndSelect(relationProperty, include[relationProperty]);
+                        oqb.leftJoinAndSelect(relationProperty, include[relationProperty]);
                     }
                     else {
-                        queryBuilder.leftJoinAndSelect(relationProperty, include[relationProperty], `${cqs}${include[relationProperty]}${cqs}.${cqs}${deletedColumnName}${cqs} IS NULL`);
+                        oqb.leftJoinAndSelect(relationProperty, include[relationProperty], `${cqs}${include[relationProperty]}${cqs}.${cqs}${deletedColumnName}${cqs} IS NULL`);
                     }
                 }
             }
             if (select && select.length) {
-                queryBuilder.select(this.parseSelect(select, include));
+                oqb.select(this.parseSelect(select, include));
             }
         }
-        if (where) {
+        else if (withDeleted === false) {
+            where[deletedColumnName] = {
+                query: `${cqs}${deletedColumnName}${cqs} IS NULL`
+            };
+        }
+        if (Object.keys(where).length) {
             let isFirst = true;
             for (const fieldName in where) {
                 const whereItem = where[fieldName];
@@ -70,10 +82,11 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 else {
                     methodName = fieldName === core_1.PersistanceSelectOperator.Or ? 'orWhere' : 'andWhere';
                 }
-                queryBuilder[methodName](whereItem.query, whereItem.params);
+                ormQueryBuilder[methodName](whereItem.query, whereItem.params);
             }
         }
-        if (orderBy && queryBuilder instanceof typeorm_1.SelectQueryBuilder) {
+        if (orderBy && 'orderBy' in ormQueryBuilder) {
+            const oqb = ormQueryBuilder;
             let isFirst = true;
             for (const item of orderBy) {
                 let methodName = 'addOrderBy';
@@ -81,18 +94,18 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                     methodName = 'orderBy';
                     isFirst = false;
                 }
-                queryBuilder[methodName](item.field, item.direction);
+                oqb[methodName](item.field, item.direction);
             }
         }
     }
-    getValueForFilter(entityName, fieldName, fieldAlias, fieldValue, isNot, operator) {
+    getValueForFilter(entityName, _fieldName, fieldAlias, fieldValue, isNot, operator) {
         const { columnQuotesSymbol: cqs, dbType } = this;
         const escapedFieldAlias = fieldAlias.replace(/\$/, '__ds__');
-        const fieldString = `${cqs}${entityName}${cqs}.${cqs}${fieldName}${cqs}`;
+        const fieldString = `${cqs}${entityName}${cqs}.${cqs}${fieldAlias}${cqs}`;
         let parsedInnerValue = fieldValue instanceof Date ? fieldValue.valueOf() : fieldValue;
         if (operator === core_1.PersistanceSelectOperator.Contains) {
             let query = '';
-            if (dbType === core_1.RDBType.MySQL) {
+            if (dbType === core_1.RDBType.Aurora || dbType === core_1.RDBType.ClickHouse || dbType === core_1.RDBType.MySQL) {
                 query = `JSON_CONTAINS(${fieldString}, :${escapedFieldAlias})`;
                 parsedInnerValue = `"${parsedInnerValue}"`;
             }
@@ -187,6 +200,7 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
         const cqs = this.columnQuotesSymbol;
         const { isTopLevel, operator } = options;
         const fieldAliases = options.fieldAliases || {};
+        const parameterNamesToFieldAliasesMap = options.parameterNamesToFieldAliasesMap || {};
         const where = {};
         let include = {};
         for (const fieldName in filters) {
@@ -194,8 +208,8 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
             if (typeof fieldValue === 'undefined') {
                 continue;
             }
-            const fieldAlias = fieldAliases[fieldName] || fieldName;
             const isNot = operator === core_1.PersistanceSelectOperator.Not;
+            let fieldAlias = fieldAliases[fieldName];
             if (fieldName.match(/\./)) {
                 const fieldData = fieldName.split('.');
                 const finalItemIndex = fieldData.length - 1;
@@ -204,12 +218,16 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 let previousEntityAlias = `${entityName}`;
                 for (let i = 0; i < finalItemIndex; i++) {
                     const currentEntityName = fieldData[i];
-                    entityAlias += `_${currentEntityName}`;
+                    entityAlias += `__${currentEntityName}`;
                     include[`${previousEntityAlias}.${currentEntityName}`] = entityAlias;
                     previousEntityAlias = `${entityAlias}`;
                 }
+                if (!fieldAlias) {
+                    fieldAlias = actualFieldName;
+                }
+                const actualFieldAlias = parameterNamesToFieldAliasesMap[fieldAlias] || fieldAlias;
                 const itemData = this.parseFilters(entityAlias, { [actualFieldName]: fieldValue }, {
-                    fieldAliases: { [actualFieldName]: fieldAlias },
+                    fieldAliases: { [actualFieldName]: actualFieldAlias },
                     isTopLevel: false,
                     operator
                 });
@@ -217,14 +235,18 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 include = Object.assign(Object.assign({}, include), itemData.include);
                 continue;
             }
+            if (!fieldAlias) {
+                fieldAlias = fieldName;
+            }
+            const actualFieldAlias = parameterNamesToFieldAliasesMap[fieldAlias] || fieldAlias;
             if (fieldValue === null) {
                 where[fieldName] = {
-                    query: `${cqs}${entityName}${cqs}.${cqs}${fieldName}${cqs} is${isNot ? ' not ' : ' '}null`
+                    query: `${cqs}${entityName}${cqs}.${cqs}${actualFieldAlias}${cqs} is${isNot ? ' not ' : ' '}null`
                 };
                 continue;
             }
             if (fieldValue instanceof Array) {
-                const { hasValues, isSimple, paramsForQuery, queryTemplateParamNames } = this.parseArrayOfFilters(fieldValue, fieldAlias);
+                const { hasValues, isSimple, paramsForQuery, queryTemplateParamNames } = this.parseArrayOfFilters(fieldValue, actualFieldAlias);
                 if (!hasValues) {
                     continue;
                 }
@@ -232,14 +254,14 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                     if (operator === core_1.PersistanceSelectOperator.Between) {
                         where[fieldName] = {
                             params: paramsForQuery,
-                            query: `${cqs}${entityName}${cqs}.${cqs}${fieldName}${cqs}${isNot ? ' not ' : ' '}` +
-                                `between :${fieldAlias}_0 and :${fieldAlias}_1`
+                            query: `${cqs}${entityName}${cqs}.${cqs}${actualFieldAlias}${cqs}${isNot ? ' not ' : ' '}` +
+                                `between :${actualFieldAlias}_0 and :${actualFieldAlias}_1`
                         };
                         continue;
                     }
                     where[fieldName] = {
                         params: paramsForQuery,
-                        query: `${cqs}${entityName}${cqs}.${cqs}${fieldName}${cqs}${isNot ? ' not ' : ' '}` +
+                        query: `${cqs}${entityName}${cqs}.${cqs}${actualFieldAlias}${cqs}${isNot ? ' not ' : ' '}` +
                             `in (${queryTemplateParamNames.replace(/,\s$/, '')})`
                     };
                     continue;
@@ -247,7 +269,7 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 if (isTopLevel && fieldName === core_1.PersistanceSelectOperator.Or) {
                     const finalWhereValue = { params: {}, query: '' };
                     fieldValue.forEach((orFieldValue, orFieldIndex) => {
-                        const itemData = this.parseInnerFilters(entityName, orFieldValue, fieldName, `${fieldAlias}_${orFieldIndex}_f`, operator);
+                        const itemData = this.parseInnerFilters(entityName, orFieldValue, fieldName, `${actualFieldAlias}_${orFieldIndex}_f`, operator);
                         finalWhereValue.params = Object.assign(Object.assign({}, finalWhereValue.params), (itemData.parsedFilter.params || {}));
                         finalWhereValue.query += `${finalWhereValue.query.length ? ' or ' : '('}${itemData.parsedFilter.query}`;
                         include = Object.assign(Object.assign({}, include), itemData.include);
@@ -256,7 +278,7 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                     where[fieldName] = finalWhereValue;
                 }
                 else {
-                    const itemData = this.parseInnerFilters(entityName, fieldValue, fieldName, fieldAlias, operator);
+                    const itemData = this.parseInnerFilters(entityName, fieldValue, fieldName, actualFieldAlias, operator);
                     if (itemData.parsedFilter.query === '()') {
                         continue;
                     }
@@ -266,12 +288,12 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 continue;
             }
             if (typeof fieldValue === 'object' && !(fieldValue instanceof Date)) {
-                const itemData = this.parseInnerFilters(entityName, fieldValue, fieldName, fieldAlias, operator);
+                const itemData = this.parseInnerFilters(entityName, fieldValue, fieldName, actualFieldAlias, operator);
                 where[fieldName] = itemData.parsedFilter;
                 include = Object.assign(Object.assign({}, include), itemData.include);
                 continue;
             }
-            where[fieldName] = this.getValueForFilter(entityName, fieldName, fieldAlias, fieldValue, isNot, operator);
+            where[fieldName] = this.getValueForFilter(entityName, fieldName, actualFieldAlias, fieldValue, isNot, operator);
         }
         return { where, include };
     }
@@ -287,11 +309,13 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
                 op = key;
             }
             const actualFieldName = fieldName === core_1.PersistanceSelectOperator.Or ? key : fieldName;
+            const fieldParameterName = `${fieldAlias}_${parsedValueCount}`;
             const innerValue = filtersObject[key];
             const itemData = this.parseFilters(entityName, { [actualFieldName]: innerValue }, {
-                fieldAliases: { [actualFieldName]: `${fieldAlias}_${parsedValueCount}` },
+                fieldAliases: { [actualFieldName]: fieldParameterName },
                 isTopLevel: false,
-                operator: op
+                operator: op,
+                parameterNamesToFieldAliasesMap: { [fieldParameterName]: fieldAlias }
             });
             const fieldWhereData = itemData.where[actualFieldName];
             if (!fieldWhereData) {
@@ -314,7 +338,7 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
             let entityAlias = `${entityName}`;
             let previousEntityAlias = `${entityName}`;
             includeData.forEach(currentEntityName => {
-                entityAlias += `_${currentEntityName}`;
+                entityAlias += `__${currentEntityName}`;
                 resultInclude[`${previousEntityAlias}.${currentEntityName}`] = entityAlias;
                 previousEntityAlias = `${entityAlias}`;
             });
@@ -325,7 +349,9 @@ let SQLQueryBuilderService = class SQLQueryBuilderService {
         const orderBy = [];
         let include = {};
         for (const fieldName in orderByData) {
-            const direction = orderByData[fieldName].toLowerCase() === 'desc' ? 'DESC' : 'ASC';
+            const direction = orderByData[fieldName].toLowerCase() === 'desc'
+                ? core_1.PersistanceOrderByDirection.Desc
+                : core_1.PersistanceOrderByDirection.Asc;
             const item = { field: `${entityName}.${fieldName}`, direction };
             if (fieldName.match(/\./)) {
                 const fieldData = fieldName.split('.');
@@ -371,6 +397,7 @@ exports.SQLQueryBuilderService = SQLQueryBuilderService;
 exports.SQLQueryBuilderService = SQLQueryBuilderService = __decorate([
     (0, common_1.Injectable)(),
     __param(1, (0, common_1.Inject)(definitions_1.Constants.SQL_BUILDER_DB_CONFIG_PATH)),
-    __metadata("design:paramtypes", [core_1.ConfigProviderService, String])
+    __param(2, (0, common_1.Inject)(core_1.Constants.PERSISTANCE_MODULE_NAME)),
+    __metadata("design:paramtypes", [core_1.ConfigProviderService, String, String])
 ], SQLQueryBuilderService);
-//# sourceMappingURL=sqlQueryBuilder.service.js.map
+//# sourceMappingURL=rdb.sqlQueryBuilder.service.js.map