@node-c/data-clickhouse 1.0.0-alpha64 → 1.0.0-beta0

package/README.md

@@ -1,4 +1,4 @@
-# Node-C / Data: RDB
+# Node-C / Data: ClickHouse
 This is Node-C's package providing the functionality for working with ClickHouse.
 
 The documentation can be found on the [Node-C Github repo homepage](https://github.com/RazorDude/node-c).

package/dist/connectionModule/clickhouse.connection.module.js

@@ -50,7 +50,7 @@ class ClickHouseConnectionModule {
                             client = (0, client_1.createClient)(connectionOptions);
                             const pingResult = yield client.ping({ select: true });
                             if (!pingResult.success) {
-                                throw new Error(JSON.stringify(pingResult));
+                                throw new core_1.ApplicationError(JSON.stringify(pingResult));
                             }
                         }
                         catch (err) {

package/dist/connectionModule/clickhouse.connection.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"clickhouse.connection.module.js","sourceRoot":"","sources":["../../src/connectionModule/clickhouse.connection.module.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAoE;AAIpE,uCAAuE;AAIvE,uDAAkD;AAElD,MAAa,0BAA0B;IACrC,MAAM,CAAC,QAAQ,CAAC,OAA0C;QACxD,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QACnC,MAAM,UAAU,GAAG,GAAG,uBAAS,CAAC,wBAAwB,GAAG,cAAc,EAAE,CAAC;QAC5E,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,0BAA0B;YAClC,OAAO,EAAE,EAAE;YACX,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,CAAO,cAAqC,EAAE,EAAE;wBAC1D,MAAM,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC;wBAC9C,MAAM,EACJ,WAAW,EACX,QAAQ,EACR,qBAAqB,GAAG,IAAI,EAC5B,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,IAAI,EACL,GAAG,UAAU,CAAC,cAAyC,CAAqB,CAAC;wBAC9E,MAAM,iBAAiB,GAAsC;4BAC3D,QAAQ;4BACR,QAAQ;4BACR,QAAQ,EAAE,IAAI;yBACf,CAAC;wBACF,MAAM,GAAG,GAAG,GAAG,QAAQ,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;wBACtD,IAAI,MAAwB,CAAC;wBAC7B,IAAI,WAAW,EAAE,CAAC;4BAChB,iBAAiB,CAAC,WAAW,GAAG,WAAW,CAAC;wBAC9C,CAAC;wBACD,IAAI,cAAc,EAAE,CAAC;4BACnB,iBAAiB,CAAC,eAAe,GAAG,cAAc,CAAC;wBACrD,CAAC;wBACD,IAAI,YAAY,EAAE,CAAC;4BACjB,iBAAiB,CAAC,IAAI,GAAG,GAAG,CAAC;wBAC/B,CAAC;6BAAM,CAAC;4BACN,iBAAiB,CAAC,GAAG,GAAG,GAAG,CAAC;wBAC9B,CAAC;wBACD,IAAI,CAAC;4BACH,MAAM,GAAG,IAAA,qBAAY,EAAC,iBAAiB,CAAC,CAAC;4BACzC,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;4BACvD,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gCACxB,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;4BAC9C,CAAC;wBACH,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,OAAO,CAAC,KAAK,CAAC,gCAAgC,cAAc,oCAAoC,EAAE,GAAG,CAAC,CAAC;4BACvG,IAAI,qBAAqB,EAAE,CAAC;gCAC1B,MAAM,GAAG,CAAC;4BACZ,CAAC;wBACH,CAAC;wBACD,OAAO,MAAO,CAAC;oBACjB,CAAC,CAAA;oBACD,MAAM,EAAE,CAAC,4BAAqB,CAAC;iBAChC;aACF;YACD,OAAO,EAAE,CAAC,UAAU,CAAC;SACtB,CAAC;IACJ,CAAC;CACF;AA/DD,gEA+DC"}
+{"version":3,"file":"clickhouse.connection.module.js","sourceRoot":"","sources":["../../src/connectionModule/clickhouse.connection.module.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAoE;AAIpE,uCAAyF;AAIzF,uDAAkD;AAElD,MAAa,0BAA0B;IACrC,MAAM,CAAC,QAAQ,CAAC,OAA0C;QACxD,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QACnC,MAAM,UAAU,GAAG,GAAG,uBAAS,CAAC,wBAAwB,GAAG,cAAc,EAAE,CAAC;QAC5E,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,0BAA0B;YAClC,OAAO,EAAE,EAAE;YACX,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,UAAU;oBACnB,UAAU,EAAE,CAAO,cAAqC,EAAE,EAAE;wBAC1D,MAAM,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC;wBAC9C,MAAM,EACJ,WAAW,EACX,QAAQ,EACR,qBAAqB,GAAG,IAAI,EAC5B,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,IAAI,EACL,GAAG,UAAU,CAAC,cAAyC,CAAqB,CAAC;wBAC9E,MAAM,iBAAiB,GAAsC;4BAC3D,QAAQ;4BACR,QAAQ;4BACR,QAAQ,EAAE,IAAI;yBACf,CAAC;wBACF,MAAM,GAAG,GAAG,GAAG,QAAQ,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;wBACtD,IAAI,MAAwB,CAAC;wBAC7B,IAAI,WAAW,EAAE,CAAC;4BAChB,iBAAiB,CAAC,WAAW,GAAG,WAAW,CAAC;wBAC9C,CAAC;wBACD,IAAI,cAAc,EAAE,CAAC;4BACnB,iBAAiB,CAAC,eAAe,GAAG,cAAc,CAAC;wBACrD,CAAC;wBACD,IAAI,YAAY,EAAE,CAAC;4BACjB,iBAAiB,CAAC,IAAI,GAAG,GAAG,CAAC;wBAC/B,CAAC;6BAAM,CAAC;4BACN,iBAAiB,CAAC,GAAG,GAAG,GAAG,CAAC;wBAC9B,CAAC;wBACD,IAAI,CAAC;4BACH,MAAM,GAAG,IAAA,qBAAY,EAAC,iBAAiB,CAAC,CAAC;4BACzC,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;4BACvD,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gCACxB,MAAM,IAAI,uBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;4BACzD,CAAC;wBACH,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,OAAO,CAAC,KAAK,CAAC,gCAAgC,cAAc,oCAAoC,EAAE,GAAG,CAAC,CAAC;4BACvG,IAAI,qBAAqB,EAAE,CAAC;gCAC1B,MAAM,GAAG,CAAC;4BACZ,CAAC;wBACH,CAAC;wBACD,OAAO,MAAO,CAAC;oBACjB,CAAC,CAAA;oBACD,MAAM,EAAE,CAAC,4BAAqB,CAAC;iBAChC;aACF;YACD,OAAO,EAAE,CAAC,UAAU,CAAC;SACtB,CAAC;IACJ,CAAC;CACF;AA/DD,gEA+DC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@node-c/data-clickhouse",
-  "version": "1.0.0-alpha64",
+  "version": "1.0.0-beta0",
   "license": "MIT",
   "main": "dist/index.js",
   "scripts": {
@@ -15,10 +15,10 @@
   },
   "dependencies": {
     "@clickhouse/client": "^1.12.1",
-    "@nestjs/common": "^10.4.12",
-    "@nestjs/typeorm": "^10.0.2",
-    "@node-c/core": "^1.0.0-alpha64",
-    "@node-c/data-rdb": "^1.0.0-alpha64",
+    "@nestjs/common": "^11.1.16",
+    "@nestjs/typeorm": "^11.0.0",
+    "@node-c/core": "^1.0.0-beta0",
+    "@node-c/data-rdb": "^1.0.0-beta0",
     "class-validator": "^0.14.1",
     "typeorm": "^0.3.20",
     "uuid": "^11.0.5"

package/src/common/definitions/common.constants.ts

@@ -0,0 +1,6 @@
+export enum Constants {
+  // eslint-disable-next-line no-unused-vars
+  CLICKHOUSE_CLIENT = 'CLICKHOUSE_CLIENT',
+  // eslint-disable-next-line no-unused-vars
+  CLICKHOUSE_CLIENT_PREFIX = 'CLICKHOUSE_CLIENT_'
+}

package/src/common/definitions/index.ts

@@ -0,0 +1 @@
+export * from './common.constants';

package/src/connectionModule/clickhouse.connection.module.definitions.ts

@@ -0,0 +1,3 @@
+export interface ClickHouseConnectionModuleOptions {
+  dataModuleName: string;
+}

package/src/connectionModule/clickhouse.connection.module.ts

@@ -0,0 +1,74 @@
+import { ClickHouseClient, createClient } from '@clickhouse/client';
+import { NodeClickHouseClientConfigOptions } from '@clickhouse/client/dist/config';
+import { DynamicModule } from '@nestjs/common';
+
+import { AppConfigDataRDB, ApplicationError, ConfigProviderService } from '@node-c/core';
+
+import { ClickHouseConnectionModuleOptions } from './clickhouse.connection.module.definitions';
+
+import { Constants } from '../common/definitions';
+
+export class ClickHouseConnectionModule {
+  static register(options: ClickHouseConnectionModuleOptions): DynamicModule {
+    const { dataModuleName } = options;
+    const clientName = `${Constants.CLICKHOUSE_CLIENT_PREFIX}${dataModuleName}`;
+    return {
+      global: true,
+      module: ClickHouseConnectionModule,
+      imports: [],
+      providers: [
+        {
+          provide: clientName,
+          useFactory: async (configProvider: ConfigProviderService) => {
+            const dataConfig = configProvider.config.data;
+            const {
+              application,
+              database,
+              failOnConnectionError = true,
+              host,
+              password,
+              port,
+              protocol,
+              requestTimeout,
+              useHostParam,
+              user
+            } = dataConfig[dataModuleName as keyof typeof dataConfig] as AppConfigDataRDB;
+            const connectionOptions: NodeClickHouseClientConfigOptions = {
+              database,
+              password,
+              username: user
+            };
+            const url = `${protocol || 'http'}://${host}:${port}`;
+            let client: ClickHouseClient;
+            if (application) {
+              connectionOptions.application = application;
+            }
+            if (requestTimeout) {
+              connectionOptions.request_timeout = requestTimeout;
+            }
+            if (useHostParam) {
+              connectionOptions.host = url;
+            } else {
+              connectionOptions.url = url;
+            }
+            try {
+              client = createClient(connectionOptions);
+              const pingResult = await client.ping({ select: true });
+              if (!pingResult.success) {
+                throw new ApplicationError(JSON.stringify(pingResult));
+              }
+            } catch (err) {
+              console.error(`[ClickHouseConnectionModule][${dataModuleName}]: Error connecting to ClickHouse:`, err);
+              if (failOnConnectionError) {
+                throw err;
+              }
+            }
+            return client!;
+          },
+          inject: [ConfigProviderService]
+        }
+      ],
+      exports: [clientName]
+    };
+  }
+}

package/src/connectionModule/index.ts

@@ -0,0 +1,2 @@
+export * from './clickhouse.connection.module.definitions';
+export * from './clickhouse.connection.module';

package/src/entityManager/clickhouse.entity.manager.ts

@@ -0,0 +1,61 @@
+import { ClickHouseClient } from '@clickhouse/client';
+import { Inject, Injectable } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+import { Constants as RDBConstants, RDBEntityManager, RDBRepository } from '@node-c/data-rdb';
+
+import { Constants } from '../common/definitions';
+
+@Injectable()
+export class ClickHouseEntityManager implements RDBEntityManager {
+  constructor(
+    @Inject(Constants.CLICKHOUSE_CLIENT)
+    // eslint-disable-next-line no-unused-vars
+    protected client: ClickHouseClient,
+    @Inject(RDBConstants.RDB_ENTITY_REPOSITORY)
+    // eslint-disable-next-line no-unused-vars
+    protected repository: RDBRepository<GenericObject<unknown>>
+  ) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getRepository<Entity extends GenericObject<unknown>>(_target: string): RDBRepository<Entity> {
+    return this.repository as RDBRepository<Entity>;
+  }
+
+  // TODO: column aliases
+  insert(data: Record<string, unknown>[]): Promise<unknown> {
+    return this.client.insert({
+      format: 'JSONEachRow',
+      table: this.repository.metadata.tableName,
+      values: data
+    });
+  }
+
+  async query<ReturnData = unknown>(
+    query: string,
+    params?: { field: string; value: string | number }[]
+  ): Promise<ReturnData> {
+    let queryParams: Record<string, string | number> | undefined = undefined;
+    if (params?.length) {
+      queryParams = {};
+      params.forEach(item => (queryParams![item.field] = item.value));
+    }
+    const results = await this.client.query({ format: 'JSON', query, query_params: queryParams });
+    const jsonData = await results.json();
+    return jsonData as ReturnData;
+  }
+
+  // TODO: figure out how to de-circularize this
+  save<Entity extends GenericObject<unknown> = GenericObject<unknown>>(
+    _target: unknown,
+    data: Partial<Entity> | Partial<Entity[]>,
+    options?: unknown
+  ): Promise<unknown> {
+    return this.repository.save(data, options);
+  }
+
+  // TODO: actual transactions
+  transaction(callback: (_em: ClickHouseEntityManager) => Promise<unknown>): Promise<unknown> {
+    return callback(this);
+  }
+}

package/src/entityManager/index.ts

@@ -0,0 +1 @@
+export * from './clickhouse.entity.manager';

package/src/entityService/clickhouse.entity.service.ts

@@ -0,0 +1,21 @@
+import { ConfigProviderService, DataDefaultData, GenericObject } from '@node-c/core';
+import { RDBEntityService, SQLQueryBuilderService } from '@node-c/data-rdb';
+
+import { ClickHouseDBEntitySchema, ClickHouseDBRepository } from '../repository';
+
+export class ClickHouseDBEntityService<
+  Entity extends GenericObject,
+  Data extends DataDefaultData<Entity> = DataDefaultData<Entity>
+> extends RDBEntityService<Entity, Data> {
+  protected primaryKeys: string[];
+
+  constructor(
+    protected configProvider: ConfigProviderService,
+    protected qb: SQLQueryBuilderService,
+    protected repository: ClickHouseDBRepository<Entity>,
+    protected schema: ClickHouseDBEntitySchema<Entity>
+  ) {
+    super(configProvider, qb, repository, schema);
+    this.primaryKeys = repository.primaryKeys;
+  }
+}

package/src/entityService/index.ts

@@ -0,0 +1 @@
+export * from './clickhouse.entity.service';

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './common/definitions';
+export * from './connectionModule';
+export * from './entityManager';
+export * from './entityService';
+export * from './module';
+export * from './ormQueryBuilder';
+export * from './repository';

package/src/module/clickhouse.module.definitions.ts

@@ -0,0 +1,18 @@
+import { ModuleMetadata } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+
+export interface ClickHouseDBModuleOptions {
+  entityModuleRegisterOptions?: unknown;
+  exports?: ModuleMetadata['exports'];
+  folderData: GenericObject<unknown>;
+  imports?: {
+    atEnd?: ModuleMetadata['imports'];
+    postORM?: ModuleMetadata['imports'];
+    preORM?: ModuleMetadata['imports'];
+  };
+  moduleClass: unknown;
+  moduleName: string;
+  providers?: ModuleMetadata['providers'];
+  registerOptionsPerEntityModule?: GenericObject;
+}

package/src/module/clickhouse.module.ts

@@ -0,0 +1,33 @@
+import { DynamicModule } from '@nestjs/common';
+
+import { loadDynamicModules } from '@node-c/core';
+import { SQLQueryBuilderModule } from '@node-c/data-rdb';
+
+import { ClickHouseDBModuleOptions } from './clickhouse.module.definitions';
+
+import { ClickHouseConnectionModule } from '../connectionModule';
+
+export class ClickHouseDBModule {
+  static register(options: ClickHouseDBModuleOptions): DynamicModule {
+    const { folderData, imports: additionalImports, moduleClass, moduleName } = options;
+    const { atEnd: importsAtEnd, postORM: importsPostORM, preORM: importsPreORM } = additionalImports || {};
+    const { modules } = loadDynamicModules(folderData, {
+      moduleRegisterOptions: options.entityModuleRegisterOptions,
+      registerOptionsPerModule: options.registerOptionsPerEntityModule
+    });
+    return {
+      global: true,
+      module: moduleClass as DynamicModule['module'],
+      imports: [
+        ...(importsPreORM || []),
+        ClickHouseConnectionModule.register({ dataModuleName: moduleName }),
+        SQLQueryBuilderModule.register({ dataModuleName: moduleName }),
+        ...(importsPostORM || []),
+        ...(modules || []),
+        ...(importsAtEnd || [])
+      ],
+      providers: [...(options.providers || [])],
+      exports: [...(modules || []), ...(options.exports || [])]
+    };
+  }
+}

package/src/module/index.ts

@@ -0,0 +1,2 @@
+export * from './clickhouse.module.definitions';
+export * from './clickhouse.module';

package/src/ormQueryBuilder/clickhouse.selectQueryBuilder.ts

@@ -0,0 +1,181 @@
+import { ApplicationError, DataOrderByDirection, GenericObject } from '@node-c/core';
+import { OrmDeleteQueryBuilder, OrmSelectQueryBuilder, OrmUpdateQueryBuilder } from '@node-c/data-rdb';
+
+import { ClickHouseEntityManager } from '../entityManager';
+import { ClickHouseDBEntitySchema } from '../repository/clickhouse.repository.definitions';
+
+// TODO: field selection, join, update, delete
+export class ClickHouseSelectQueryBuilder<Entity extends GenericObject<unknown>>
+  implements OrmSelectQueryBuilder<Entity>
+{
+  protected deletedColumn?: string;
+  protected limitClause: string = '';
+  protected offsetClause: string = '';
+  protected orderByClause: string = '';
+  protected whereClause: string = '';
+  protected withDeletedEnabled: boolean = false;
+
+  constructor(
+    // eslint-disable-next-line no-unused-vars
+    protected manager: ClickHouseEntityManager,
+    // eslint-disable-next-line no-unused-vars
+    protected schema: ClickHouseDBEntitySchema<Entity>
+  ) {
+    const {
+      options: { columns }
+    } = schema;
+    for (const columnName in columns) {
+      if (columns[columnName].isDeletionDate) {
+        this.deletedColumn = columnName;
+        break;
+      }
+    }
+  }
+
+  protected addDeletedToWhereClause(): string {
+    const { deletedColumn, whereClause, withDeletedEnabled } = this;
+    return !withDeletedEnabled && deletedColumn
+      ? `${whereClause.replace('where ', 'where (')}) and \`${deletedColumn}\` is null`
+      : whereClause;
+  }
+
+  addOrderBy(field: string, direction: DataOrderByDirection): ClickHouseSelectQueryBuilder<Entity> {
+    this.orderByClause += `, ${this.parseOrderByClause(field, direction)}`;
+    return this;
+  }
+
+  andWhere(query: string, params?: GenericObject<unknown>): ClickHouseSelectQueryBuilder<Entity> {
+    this.whereClause += ` and (${this.parseWhereClause(query, params)})`;
+    return this;
+  }
+
+  delete(): OrmDeleteQueryBuilder<Entity> {
+    throw new ApplicationError('Method ClickHouseSelectQueryBuilder.delete not implemented.');
+  }
+
+  async getCount(): Promise<number> {
+    const {
+      limitClause,
+      offsetClause,
+      orderByClause,
+      schema: {
+        options: { name, tableName }
+      }
+    } = this;
+    const result = await this.manager.query<{ data: [{ 'count()': string }] }>(
+      `select count() from \`${tableName}\` as \`${name}\` ` +
+        `${this.addDeletedToWhereClause()} ${orderByClause} ${limitClause} ${offsetClause}`
+    );
+    return parseInt(result.data[0]?.['count()'], 10);
+  }
+
+  async getMany(): Promise<Entity[]> {
+    const {
+      limitClause,
+      offsetClause,
+      orderByClause,
+      schema: {
+        options: { name, tableName }
+      }
+    } = this;
+    const result = await this.manager.query<{ data: Entity[] }>(
+      `select * from \`${tableName}\` as \`${name}\` ` +
+        `${this.addDeletedToWhereClause()} ${orderByClause} ${limitClause} ${offsetClause}`
+    );
+    return result.data;
+  }
+
+  async getOne(): Promise<Entity | null> {
+    const {
+      orderByClause,
+      schema: {
+        options: { name, tableName }
+      }
+    } = this;
+    const result = await this.manager.query<{ data: Entity }>(
+      `select * from \`${tableName}\` as \`${name}\` ${this.addDeletedToWhereClause()} ${orderByClause} limit 1`
+    );
+    return result.data || null;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  leftJoinAndSelect(..._args: unknown[]): ClickHouseSelectQueryBuilder<Entity> {
+    throw new ApplicationError('Method ClickHouseSelectQueryBuilder.leftJoinAndSelect not implemented.');
+  }
+
+  orWhere(query: string, params?: GenericObject<unknown>): ClickHouseSelectQueryBuilder<Entity> {
+    this.whereClause += ` or (${this.parseWhereClause(query, params)})`;
+    return this;
+  }
+
+  orderBy(field: string, direction: DataOrderByDirection): ClickHouseSelectQueryBuilder<Entity> {
+    this.orderByClause += `order by ${this.parseOrderByClause(field, direction)}`;
+    return this;
+  }
+
+  protected parseOrderByClause(field: string, direction: DataOrderByDirection): string {
+    return `${field.replace(/[';]/g, '')} ${direction.replace(/[';]/g, '')}`;
+  }
+
+  protected parseWhereClause(query: string, params?: GenericObject<unknown>): string {
+    let queryWithReplacements = `${query.replace(/[';]/g, '')}`;
+    if (params) {
+      for (const paramName in params) {
+        const rawValue = params[paramName];
+        if (typeof rawValue === 'undefined') {
+          continue;
+        }
+        // TODO: process dates, arrays and stringifyable objects
+        let value = '';
+        if (typeof rawValue === 'string') {
+          value = `'${rawValue.replace(/'/g, "\'")}'`;
+        } else {
+          value = `${rawValue}`;
+        }
+        queryWithReplacements = queryWithReplacements.replace(`:${paramName}`, value);
+      }
+    }
+    return queryWithReplacements;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  select(_selection: string[]): ClickHouseSelectQueryBuilder<Entity> {
+    throw new ApplicationError('Method ClickHouseSelectQueryBuilder.select not implemented.');
+  }
+
+  skip(skipCount: number): ClickHouseSelectQueryBuilder<Entity> {
+    // we need this to prevent SQL injection, since TS types don't work at runtime
+    if (typeof skipCount !== 'number') {
+      throw new ApplicationError('Method ClickHouseSelectQueryBuilder.skip expects a number input for skipCount.');
+    }
+    this.offsetClause = `offset ${skipCount}`;
+    return this;
+  }
+
+  softDelete(): OrmDeleteQueryBuilder<Entity> {
+    throw new ApplicationError('Method ClickHouseSelectQueryBuilder.softDelete not implemented.');
+  }
+
+  take(takeCount: number): ClickHouseSelectQueryBuilder<Entity> {
+    // we need this to prevent SQL injection, since TS types don't work at runtime
+    if (typeof takeCount !== 'number') {
+      throw new ApplicationError('Method ClickHouseSelectQueryBuilder.take expects a number input for takeCount.');
+    }
+    this.limitClause += `limit ${takeCount}`;
+    return this;
+  }
+
+  update(): OrmUpdateQueryBuilder<Entity> {
+    throw new ApplicationError('Method ClickHouseSelectQueryBuilder.update not implemented.');
+  }
+
+  where(query: string, params?: GenericObject<unknown>): ClickHouseSelectQueryBuilder<Entity> {
+    this.whereClause += `where (${this.parseWhereClause(query, params)})`;
+    return this;
+  }
+
+  withDeleted(): OrmSelectQueryBuilder<Entity> {
+    this.withDeletedEnabled = true;
+    return this;
+  }
+}

package/src/ormQueryBuilder/index.ts

@@ -0,0 +1 @@
+export * from './clickhouse.selectQueryBuilder';

package/src/repository/clickhouse.repository.definitions.ts

@@ -0,0 +1,49 @@
+import { GenericObject } from '@node-c/core';
+import { RDBEntitySchema } from '@node-c/data-rdb';
+
+export interface ClickHouseDBEntitySchema<EntityClass extends GenericObject<unknown>> extends RDBEntitySchema {
+  options: {
+    columns: {
+      // eslint-disable-next-line no-unused-vars
+      [columnName in keyof EntityClass]: ClickHouseDBEntitySchemaColumnOptions;
+    };
+    name: string;
+    paranoid?: boolean;
+    tableName: string;
+  };
+}
+
+export interface ClickHouseDBEntitySchemaColumnOptions {
+  generated?: boolean;
+  isCreationDate?: boolean;
+  isDeletionDate?: boolean;
+  isUpdateDate?: boolean;
+  primary?: boolean;
+  type?: ClickHouseDBEntitySchemaColumnType;
+}
+
+export enum ClickHouseDBEntitySchemaColumnType {
+  // eslint-disable-next-line no-unused-vars
+  BigInteger = 'BIGINT',
+  // eslint-disable-next-line no-unused-vars
+  Boolean = 'BOOL',
+  // eslint-disable-next-line no-unused-vars
+  DateTime = 'DATETIME',
+  // eslint-disable-next-line no-unused-vars
+  Enum = 'ENUM',
+  // eslint-disable-next-line no-unused-vars
+  Integer = 'INT',
+  // eslint-disable-next-line no-unused-vars
+  JSON = 'JSON',
+  // eslint-disable-next-line no-unused-vars
+  Text = 'TEXT',
+  // eslint-disable-next-line no-unused-vars
+  UUID = 'UUID',
+  // eslint-disable-next-line no-unused-vars
+  Varchar = 'VARCHAR'
+}
+
+export interface ClickHouseDBRepositoryModuleOptions<EntityClass extends GenericObject<unknown>> {
+  entitySchema: ClickHouseDBEntitySchema<EntityClass>;
+  dataModuleName: string;
+}

package/src/repository/clickhouse.repository.module.ts

@@ -0,0 +1,58 @@
+import { ClickHouseClient } from '@clickhouse/client';
+import { DynamicModule, Module } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+import { Constants as RDBConstants, SQLQueryBuilderService } from '@node-c/data-rdb';
+
+import { ClickHouseDBRepository } from './clickhouse.repository';
+import { ClickHouseDBRepositoryModuleOptions } from './clickhouse.repository.definitions';
+
+import { Constants } from '../common/definitions';
+import { ClickHouseEntityManager } from '../entityManager';
+
+@Module({})
+export class ClickHouseDBRepositoryModule {
+  static register<Entity extends GenericObject<unknown>>(
+    options: ClickHouseDBRepositoryModuleOptions<Entity>
+  ): DynamicModule {
+    const { entitySchema, dataModuleName } = options;
+    const clientName = `${Constants.CLICKHOUSE_CLIENT_PREFIX}${dataModuleName}`;
+    return {
+      module: ClickHouseDBRepositoryModule,
+      providers: [
+        {
+          provide: SQLQueryBuilderService,
+          useFactory: (sqlQueryBuilderService: SQLQueryBuilderService) => sqlQueryBuilderService,
+          inject: [`${dataModuleName}${RDBConstants.SQL_BUILDER_SERVICE_TOKEN_SUFFIX}`]
+        },
+        {
+          provide: Constants.CLICKHOUSE_CLIENT,
+          useFactory: (clickhouseClient: ClickHouseClient) => clickhouseClient,
+          inject: [clientName]
+        },
+        {
+          provide: RDBConstants.RDB_REPOSITORY_ENTITY_CLASS,
+          useValue: entitySchema
+        },
+        ClickHouseEntityManager,
+        ClickHouseDBRepository<Entity>,
+        {
+          provide: RDBConstants.RDB_ENTITY_REPOSITORY,
+          useExisting: ClickHouseDBRepository<Entity>
+        }
+      ],
+      exports: [
+        SQLQueryBuilderService,
+        {
+          provide: RDBConstants.RDB_ENTITY_REPOSITORY,
+          useExisting: ClickHouseDBRepository<Entity>
+        },
+        {
+          provide: Constants.CLICKHOUSE_CLIENT,
+          useFactory: (clickhouseClient: ClickHouseClient) => clickhouseClient,
+          inject: [clientName]
+        }
+      ]
+    };
+  }
+}

package/src/repository/clickhouse.repository.ts

@@ -0,0 +1,68 @@
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+import { Constants as RDBConstants, RDBRepository } from '@node-c/data-rdb';
+
+import { ClickHouseDBEntitySchema } from './clickhouse.repository.definitions';
+
+import { ClickHouseEntityManager } from '../entityManager';
+import { ClickHouseSelectQueryBuilder } from '../ormQueryBuilder';
+
+// TODO: save method
+@Injectable()
+export class ClickHouseDBRepository<Entity extends GenericObject<unknown>> implements RDBRepository<Entity> {
+  readonly metadata: { name: string; tableName: string };
+  readonly primaryKeys: string[];
+  readonly target: string;
+
+  constructor(
+    @Inject(RDBConstants.RDB_REPOSITORY_ENTITY_CLASS)
+    protected entitySchema: ClickHouseDBEntitySchema<Entity>,
+    @Inject(forwardRef(() => ClickHouseEntityManager))
+    // eslint-disable-next-line no-unused-vars
+    public readonly manager: ClickHouseEntityManager
+  ) {
+    const {
+      options: { columns, name, tableName }
+    } = entitySchema;
+    const primaryKeys: string[] = [];
+    this.metadata = { name, tableName };
+    for (const columnName in columns) {
+      if (columns[columnName]?.primary) {
+        primaryKeys.push(columnName);
+      }
+    }
+    this.primaryKeys = primaryKeys;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  createQueryBuilder(_entityName: string, _queryRunner?: unknown): ClickHouseSelectQueryBuilder<Entity> {
+    return new ClickHouseSelectQueryBuilder(this.manager, this.entitySchema);
+  }
+
+  // TODO: update
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  save(data: Partial<Entity> | Partial<Entity[]>, _options?: unknown): Promise<unknown> {
+    // throw new ApplicationError('Method ClickHouseDBRepository.save not implemented.');
+    const dataInput = (data instanceof Array ? data : [data]) as Entity[];
+    // const {
+    //   options: { columns }
+    // } = this.entitySchema;
+    // const columnsMap: GenericObject<boolean> = {};
+    // const params: GenericObject<unknown> = {};
+    // // first pass - go through all data items and make a list of columns for the header of the insert query
+    // dataInput.forEach(dataItem => {
+    //   for (const columnName in columns) {
+    //     const value = dataItem[columnName];
+    //     if (typeof value === 'undefined') {
+    //       continue;
+    //     }
+    //     if (!columnsMap[columnName]) {
+    //       columnsMap[columnName] = true;
+    //     }
+    //   }
+    // });
+    // // second pass - prepare the data itself
+    return this.manager.insert(dataInput);
+  }
+}

package/src/repository/index.ts

@@ -0,0 +1,3 @@
+export * from './clickhouse.repository';
+export * from './clickhouse.repository.definitions';
+export * from './clickhouse.repository.module';