@onivoro/server-typeorm-postgres 24.9.0 → 24.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onivoro/server-typeorm-postgres",
-  "version": "24.9.0",
+  "version": "24.11.0",
   "type": "commonjs",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -18,5 +18,11 @@
     "reflect-metadata": "~0.2.2",
     "typeorm": "^0.3.22",
     "typeorm-naming-strategies": "~4.1.0"
-  }
+  },
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.js.map",
+    "README.md"
+  ]
 }

package/jest.config.ts

@@ -1,11 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'lib-server-typeorm-postgres',
-  preset: '../../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../../coverage/libs/server/typeorm-postgres',
-};

package/project.json

@@ -1,32 +0,0 @@
-{
-  "name": "lib-server-typeorm-postgres",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/server/typeorm-postgres/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/js:tsc",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/libs/server/typeorm-postgres",
-        "main": "libs/server/typeorm-postgres/src/index.ts",
-        "tsConfig": "libs/server/typeorm-postgres/tsconfig.lib.json",
-        "assets": [
-          "libs/server/typeorm-postgres/README.md",
-          "libs/server/typeorm-postgres/package.json"
-        ],
-        "declaration": true,
-        "updateBuildableProjectPackageJsonDependencies": true,
-        "rootDir": "libs/server/typeorm-postgres/src"
-      }
-    },
-    "publish": {
-      "executor": "@nx/js:npm",
-      "outputs": [],
-      "options": {
-        "packageRoot": "dist/libs/server/typeorm-postgres"
-      }
-    }
-  },
-  "tags": []
-}

package/src/index.ts

@@ -1,33 +0,0 @@
-export * from './lib/classes/column-migration-base.class';
-export * from './lib/classes/columns-migration-base.class';
-export * from './lib/classes/drop-column-migration-base.class';
-export * from './lib/classes/drop-table-migration-base.class';
-export * from './lib/classes/index-migration-base.class';
-export * from './lib/classes/redshift-repository.class';
-export * from './lib/classes/sql-writer.class';
-export * from './lib/classes/table-migration-base.class';
-export * from './lib/classes/type-orm-paging-repository.class';
-export * from './lib/classes/type-orm-repository.class';
-
-export * from './lib/constants/many-to-one-relation-options.constant';
-
-export * from './lib/decorators/nullable-table-column.decorator';
-export * from './lib/decorators/primary-table-column.decorator';
-export * from './lib/decorators/table-column.decorator';
-export * from './lib/decorators/table.decorator';
-
-export * from './lib/functions/data-source-config-factory.function';
-export * from './lib/functions/data-source-factory.function';
-export * from './lib/functions/generate-date-query.function';
-export * from './lib/functions/get-api-type-from-column.function';
-export * from './lib/functions/get-paging-key.function';
-export * from './lib/functions/get-skip.function';
-export * from './lib/functions/remove-falsey-keys.function';
-
-export * from './lib/types/data-source-options.interface';
-export * from './lib/types/entity-provider.interface';
-export * from './lib/types/page-params.interface';
-export * from './lib/types/paged-data.interface';
-export * from './lib/types/table-meta.type';
-
-export * from './lib/server-typeorm-postgres.module';

package/src/lib/classes/__snapshots__/sql-writer.class.spec.ts.snap

@@ -1,8 +0,0 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`SqlWriter addColumn worx 1`] = `"ALTER TABLE "blah" ADD "id" character varying PRIMARY KEY "`;
-
-exports[`SqlWriter createTable worx 1`] = `
-"CREATE TABLE "blah" ("id" character varying PRIMARY KEY ,
-"active" boolean NOT NULL );"
-`;

package/src/lib/classes/column-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class ColumnMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public option: TableColumnOptions,
-    ) { }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.addColumn(this.table, this.option));
-    }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropColumn(this.table, this.option));
-    }
-}

package/src/lib/classes/columns-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class ColumnsMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public options: TableColumnOptions[],
-    ) { }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.addColumns(this.table, this.options));
-    }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropColumns(this.table, this.options));
-    }
-}

package/src/lib/classes/drop-column-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class DropColumnMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public option: TableColumnOptions,
-    ) { }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.addColumn(this.table, this.option));
-    }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropColumn(this.table, this.option));
-    }
-}

package/src/lib/classes/drop-table-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class DropTableMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public options: TableColumnOptions[],
-    ) { }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.createTable(this.table, this.options));
-    }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropTable(this.table));
-    }
-}

package/src/lib/classes/index-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumn, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class UniqueIndexMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public option: TableColumnOptions,
-    ) { }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.createUniqueIndex(this.table, this.option.name));
-    }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropIndex(SqlWriter.getIndexName(this.table, this.option.name)));
-    }
-}

package/src/lib/classes/redshift-repository.class.ts

@@ -1,146 +0,0 @@
-import { Injectable, NotImplementedException } from '@nestjs/common';
-import { DataSource, EntityManager, FindManyOptions, FindOneOptions, FindOptionsWhere } from 'typeorm';
-import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
-import { TypeOrmRepository } from './type-orm-repository.class';
-import { TTableMeta } from '../types/table-meta.type';
-import { TKeysOf } from '@onivoro/isomorphic-common';
-
-@Injectable()
-export class RedshiftRepository<TEntity> extends TypeOrmRepository<TEntity> {
-
-  constructor(public entityType: any, public entityManager: EntityManager) {
-    super(entityType, entityManager);
-  }
-
-  override async getMany(options: FindManyOptions<TEntity>): Promise<TEntity[]> {
-    const { query, queryParams } = this.buildSelectStatement(options);
-
-    return await this.queryAndMap(query, queryParams.map(_ => (_ as any).value ? (_ as any).value : _));
-  }
-
-  override async getOne(options: FindOneOptions<TEntity>): Promise<TEntity> {
-    const results = await this.getMany(options);
-
-    if (results.length > 1) {
-      throw new Error(`RedshiftRepository.getOne expected one result but found ${results.length} results`);
-    }
-
-    return results[0];
-  }
-
-  override async delete(where: FindOptionsWhere<TEntity>): Promise<void> {
-    const { query, queryParams } = this.buildDeleteStatement(where);
-
-    await this.query(query, queryParams);
-  }
-
-  override async patch(where: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void> {
-    const queryParams: any[] = [];
-    let whereClause = '';
-
-    Object.entries(where).forEach(([propertyPath, value], index) => {
-      const key = this.columns[propertyPath as keyof TEntity].databasePath;
-      if (index === 0) {
-        whereClause += ` WHERE ${key} = ${this.mapPlaceholderExpression(0, index, propertyPath)}`;
-      } else {
-        whereClause += ` AND ${key} = ${this.mapPlaceholderExpression(0, index, propertyPath)}`;
-      }
-      queryParams.push(value);
-    });
-
-    const setParams: any[] = [];
-    let setExpressions: string[] = [];
-
-    const length = queryParams?.length;
-
-    Object.entries(body).forEach(([key, value], index) => {
-      setExpressions.push(`${this.columns[key as keyof TEntity].databasePath} = ${this.mapPlaceholderExpression(length, index, key)}`);
-      setParams.push(value);
-    });
-
-    let query = `UPDATE ${this.getTableNameExpression()} SET ${setExpressions.join(', ')} ${whereClause}`;
-
-    await this.query(query, [...queryParams, ...setParams]);
-  }
-
-  override async postOne(entity: Partial<TEntity>): Promise<TEntity> {
-    await this.postOneWithoutReturn(entity);
-
-    return await this.getOne({ where: entity as any });
-  }
-
-  override async postMany(entities: Partial<TEntity>[]): Promise<TEntity[]> {
-    if (entities?.length) {
-      const { insertQuery, values } = this.buildInsertManyQuery(entities);
-
-      await this.query(insertQuery, values);
-
-      const { selectQuery, values: selectValues } = this.buildSelectManyQuery(entities);
-
-      return await this.queryAndMap(selectQuery, selectValues);
-    }
-
-    return [];
-  }
-
-  override async put(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void> {
-    this.throwNotImplemented('put');
-  }
-
-  override forTransaction(entityManager: EntityManager): TypeOrmRepository<TEntity> {
-    this.throwNotImplemented('forTransaction');
-    return this;
-  }
-
-  override async getManyAndCount(options: FindManyOptions<TEntity>): Promise<[TEntity[], number]> {
-    this.throwNotImplemented('getManyAndCount');
-    return [[], 0];
-  }
-
-  override async softDelete(where: FindOptionsWhere<TEntity>): Promise<void> {
-    await this.patch(where, { deletedAt: new Date().toISOString() } as any);
-  }
-
-  async postOneWithoutReturn(entity: Partial<TEntity>): Promise<void> {
-    // PERFORM AN INSERT BUT NOT THE RETRIEVAL QUERY FOR PERFORMANCE
-    const { insertQuery, values } = this.buildInsertQuery(entity);
-
-    await this.query(insertQuery, values);
-  }
-
-  async postManyWithoutReturn(entities: Partial<TEntity>[]): Promise<void> {
-    // TODO: PERFORM AN INSERT BUT NOT THE RETRIEVAL QUERY FOR PERFORMANCE
-    // TODO: THIS IS ACTUALLY NEEDED TO HELP WITH LARGE DATASETS
-    this.throwNotImplemented('postManyWithoutReturn');
-  }
-
-  private throwNotImplemented(feature: string) {
-    throw new NotImplementedException(`RedshiftRepository of type "${this.entityType?.name}" has no implementation for "${feature}"`);
-  }
-
-  protected override mapPlaceholderExpression(length: number, index: number, column: string) {
-    const exp = `$${length + index + 1}`;
-    const meta: TTableMeta = this.columns[column as keyof TEntity];
-    return meta.type === 'jsonb' ? `JSON_PARSE(${exp})` : exp;
-  }
-
-  static buildFromMetadata<TGenericEntity>(dataSource: DataSource, _: {schema: string, table: string, columns: TKeysOf<TGenericEntity, TTableMeta>}) {
-
-      class GenericRepository extends RedshiftRepository<TGenericEntity> {
-        constructor() {
-          const entityManager = dataSource.createEntityManager();
-          super(Object, {
-            ...entityManager,
-            getRepository: () => entityManager as any
-          } as any);
-        }
-      }
-
-      const genericRepository = new GenericRepository();
-      (genericRepository as any).schema = _.schema;
-      (genericRepository as any).table = _.table;
-      (genericRepository as any).columns = _.columns;
-
-      return genericRepository as RedshiftRepository<TGenericEntity>;
-    }
-}

package/src/lib/classes/sql-writer.class.spec.ts

@@ -1,20 +0,0 @@
-import { SqlWriter } from './sql-writer.class';
-
-describe(SqlWriter.name, () => {
-    describe(SqlWriter.addColumn.name, () => {
-        it('worx', () => {
-            expect(SqlWriter.addColumn('blah', {
-                isPrimary: true, name: 'id', type: 'character varying'
-            })).toMatchSnapshot();
-        });
-    });
-
-    describe(SqlWriter.createTable.name, () => {
-        it('worx', () => {
-            expect(SqlWriter.createTable('blah', [
-                { isPrimary: true, name: 'id', type: 'character varying' },
-                { isPrimary: false, name: 'active', type: 'boolean' },
-            ])).toMatchSnapshot();
-        });
-    });
-});

package/src/lib/classes/sql-writer.class.ts

@@ -1,66 +0,0 @@
-import { TableColumnOptions } from "typeorm";
-
-export class SqlWriter {
-
-    public static addColumn(table: string, option: TableColumnOptions) {
-        const notNullExpression = option.isPrimary ? ` PRIMARY KEY ` : (option.isNullable ? '' : ' NOT NULL ');
-        const foreignKey = option.foreignKeyConstraintName ? ` REFERENCES ${option.foreignKeyConstraintName} ` : '';
-        const uniqueExpression = option.isUnique ? ' UNIQUE ' : '';
-        return `ALTER TABLE "${table}" ADD "${option.name}" ${option.type}${notNullExpression}${uniqueExpression}${SqlWriter.getDefaultValueExpression(option)}${foreignKey}`;
-    }
-
-    public static createTable(table: string, options: TableColumnOptions[]) {
-        const cols = options.map(option => SqlWriter.addColumn(table, option).replace(`ALTER TABLE "${table}" ADD `, '')).join(',\n');
-
-        return `CREATE TABLE "${table}" (${cols});`;
-    }
-
-    public static dropTable(table: string) {
-        return `DROP TABLE "${table}";\n`;
-    }
-
-    public static addColumns(table: string, options: TableColumnOptions[]) {
-        return options.map(option => SqlWriter.addColumn(table, option)).join('; \n');
-    }
-
-    public static dropColumn(table: string, option: TableColumnOptions) {
-        return `ALTER TABLE "${table}" DROP COLUMN ${option.name}`;
-    }
-
-    public static dropColumns(table: string, options: TableColumnOptions[]) {
-        return options.map(option => SqlWriter.dropColumn(table, option)).join('; \n');
-    }
-
-    public static dropIndex(index: string): string {
-        return `DROP INDEX IF EXISTS ${index}`;
-    }
-
-    public static createIndex(table: string, column: string, unique: boolean): string {
-        const index = SqlWriter.getIndexName(table, column);
-        return `CREATE ${unique ? 'UNIQUE' : ''} INDEX IF NOT EXISTS ${index} ON "${table}"(${column})`;
-    }
-
-    public static getIndexName(table: string, column: string): string {
-        return `${table}_${column}`;
-    }
-
-    public static createUniqueIndex(table: string, column: string): string {
-        return SqlWriter.createIndex(table, column, true);
-    }
-
-    public static getDefaultValueExpression(option: TableColumnOptions) {
-        if (typeof option.default === 'undefined') {
-            return '';
-        }
-
-        if (['json', 'jsonb'].includes(option.type)) {
-            return ` DEFAULT '${JSON.stringify(option.default)}'::${option.type} `;
-        }
-
-        if (['boolean', 'bigint', 'int'].includes(option.type)) {
-            return ` DEFAULT ${option.default.toString().toUpperCase()} `;
-        }
-
-        return ` DEFAULT '${option.default}' `;
-    }
-}

package/src/lib/classes/table-migration-base.class.ts

@@ -1,17 +0,0 @@
-import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
-import { SqlWriter } from "./sql-writer.class";
-
-export class TableMigrationBase implements MigrationInterface {
-    constructor(
-        public table: string,
-        public options: TableColumnOptions[],
-    ) { }
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.createTable(this.table, this.options));
-    }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(SqlWriter.dropTable(this.table));
-    }
-}

package/src/lib/classes/type-orm-paging-repository.class.ts

@@ -1,22 +0,0 @@
-import {
-  EntityManager,
-} from 'typeorm';
-
-import { TypeOrmRepository } from './type-orm-repository.class';
-import { IPagedData } from '../types/paged-data.interface';
-import { getSkip } from '../functions/get-skip.function';
-import { removeFalseyKeys } from '../functions/remove-falsey-keys.function';
-import { getPagingKey } from '../functions/get-paging-key.function';
-import { IPageParams } from '../types/page-params.interface';
-
-export abstract class TypeOrmPagingRepository<TEntity, TEntityParams> extends TypeOrmRepository<TEntity> {
-  protected getPagingKey = getPagingKey;
-  protected getSkip = getSkip;
-  protected removeFalseyKeys = removeFalseyKeys;
-
-  constructor(entityType: any, entityManager: EntityManager) {
-    super(entityType, entityManager);
-  }
-
-  abstract getPage(pageParams: IPageParams, params: TEntityParams): Promise<IPagedData<TEntity>>;
-}

package/src/lib/classes/type-orm-repository.class.ts

@@ -1,299 +0,0 @@
-import {
-  DataSource,
-  EntityManager,
-  FindManyOptions,
-  FindOneOptions,
-  FindOptionsWhere,
-  ILike,
-} from 'typeorm';
-
-import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
-import { IEntityProvider } from '../types/entity-provider.interface';
-import { TKeysOf } from '@onivoro/isomorphic-common';
-import { TTableMeta } from '../types/table-meta.type';
-
-export class TypeOrmRepository<TEntity> implements IEntityProvider<
-  TEntity,
-  FindOneOptions<TEntity>,
-  FindManyOptions<TEntity>,
-  FindOptionsWhere<TEntity>,
-  QueryDeepPartialEntity<TEntity>
-> {
-  columns: TKeysOf<TEntity, TTableMeta> = {} as any;
-  table: string;
-  schema: string;
-  debug = false;
-
-  constructor(public entityType: any, public entityManager: EntityManager) {
-
-    const { tableName, schema } = this.repo.metadata;
-
-    this.table = tableName;
-    this.schema = schema!;
-
-    this.repo.metadata.columns.forEach((_) => {
-      const { databasePath, propertyPath, type, isPrimary } = _;
-      this.columns[propertyPath as keyof TEntity] = { databasePath, type, propertyPath, isPrimary, default: _.default };
-    })
-  }
-
-  forTransaction(entityManager: EntityManager): TypeOrmRepository<TEntity> {
-    return new (this.constructor as typeof TypeOrmRepository<TEntity>)(this.entityType, entityManager);
-  }
-
-  async getMany(options: FindManyOptions<TEntity>): Promise<TEntity[]> {
-    return await (this.repo.find as any)(options);
-  }
-
-  async getManyAndCount(options: FindManyOptions<TEntity>): Promise<[TEntity[], number]> {
-    return await (this.repo.findAndCount as any)(options);
-  }
-
-  async getOne(options: FindOneOptions<TEntity>): Promise<TEntity> {
-    const results = await this.getMany(options);
-
-    if (results?.length > 1) {
-      throw new Error(`${TypeOrmRepository.prototype.getOne.name} expects only 1 result but found ${results.length} results of entity type "${this.entityType}" for criteria ${JSON.stringify(options, null, 2)}`);
-    }
-
-    return results[0];
-  }
-
-  async postOne(body: Partial<TEntity>): Promise<TEntity> {
-    return await this.insertAndReturn(body as TEntity);
-  }
-
-  async postMany(body: Partial<TEntity>[]): Promise<TEntity[]> {
-    return (await this.insertAndReturnMany(body as TEntity[])) as  any;
-  }
-
-  async delete(options: FindOptionsWhere<TEntity>): Promise<void> {
-    return await (this.repo.delete as any)(options);
-  }
-
-  async softDelete(options: FindOptionsWhere<TEntity>): Promise<void> {
-    return await (this.repo.softDelete as any)(options);
-  }
-
-  async put(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>) {
-    await this.repo.save(options, body);
-  }
-
-  async patch(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>) {
-    await this.repo.update(options, body);
-  }
-
-  get repo() {
-    return this.entityManager.getRepository(this.entityType as any);
-  }
-
-  protected async insertAndReturn(entityToInsert: TEntity): Promise<TEntity> {
-    return (await this.insertAndReturnMany([entityToInsert]))[0];
-  }
-
-  protected async insertAndReturnMany(entitiesToInsert: TEntity[]): Promise<TEntity[]> {
-    const insertionResult = await this.repo
-      .createQueryBuilder()
-      .insert()
-      .values(entitiesToInsert)
-      .returning('*')
-      .execute();
-
-    const insertedEntity: TEntity[] =
-      insertionResult.generatedMaps as TEntity[];
-
-    return insertedEntity;
-  }
-
-  protected getSchemaPrefix() {
-    return this.schema ? `"${this.schema}".` : '';
-  }
-
-  protected getTableNameExpression() {
-    const schemaPrefix = this.getSchemaPrefix();
-    return `${schemaPrefix}"${this.table}"`;
-  }
-
-  protected buildSelectStatement(options: FindManyOptions<TEntity>): { query: string; queryParams: any[]; } {
-    const { whereClause, queryParams } = this.buildWhereExpression(options.where as FindOptionsWhere<TEntity>);
-    const query = `SELECT * FROM ${this.getTableNameExpression()}${whereClause};`;
-    return { query, queryParams };
-  }
-
-  protected buildDeleteStatement(where: FindManyOptions<TEntity>): { query: string; queryParams: any[]; } {
-    const { whereClause, queryParams } = this.buildWhereExpression(where as FindOptionsWhere<TEntity>);
-    const query = `DELETE FROM ${this.getTableNameExpression()}${whereClause};`;
-    return { query, queryParams };
-  }
-
-  protected buildWhereExpression(where?: FindOptionsWhere<TEntity>) {
-    const queryParams: any[] = [];
-    let whereClause = '';
-
-    Object.entries(where || {}).forEach(([propertyPath, value], index) => {
-      const key = this.columns[propertyPath as keyof TEntity].databasePath;
-
-      const where = Array.isArray((value as any).value)
-        ? `${key} = ANY($${index + 1})`
-        : `${key} = $${index + 1}`;
-
-      if (index === 0) {
-        whereClause += ` WHERE ${where}`;
-      } else {
-        whereClause += ` AND ${where}`;
-      }
-      queryParams.push(value);
-    });
-
-    return { queryParams, whereClause };
-  }
-
-  protected buildInsertQuery(entity: Partial<TEntity>): { insertQuery: string, values: any[] } {
-    const keys: Array<keyof TEntity> = Object.keys(entity) as any;
-    const values = Object.values(entity);
-
-    const columnNames = keys.map(key => this.columns[key].databasePath).join(', ');
-    const paramPlaceholders = keys.map((key, index) => this.mapPlaceholderExpression(0, index, key as string)).join(', ');
-
-    const insertQuery = `INSERT INTO ${this.getTableNameExpression()} (${columnNames}) VALUES (${paramPlaceholders})`;
-
-    return { insertQuery, values };
-  }
-
-  protected buildInsertManyQuery(entities: Partial<TEntity>[]): { insertQuery: string, values: any[] } {
-    const keyMap: Record<keyof TEntity, boolean> = {} as any;
-
-    entities.forEach(entity => {
-      (Object.keys(entity) as Array<keyof TEntity>)
-        .forEach(key => {
-          keyMap[key] = true;
-        });
-    });
-
-    const columnNames = (Object.keys(keyMap) as Array<keyof TEntity>).map(key => this.columns[key].databasePath).join(', ');
-
-    const valuesExpressions: string[] = [];
-    const values: any[] = [];
-
-    entities.forEach(entity => {
-      const length = values.length;
-
-      (Object.keys(keyMap) as Array<keyof TEntity>).forEach((key) => {
-        values.push((typeof entity[key] === 'undefined') ? this.columns[key].default : entity[key]);
-      });
-
-      const paramPlaceholders = Object.keys(keyMap).map((_, index) => this.mapPlaceholderExpression(length, index, _)).join(', ');
-
-      valuesExpressions.push(`(${paramPlaceholders})`);
-    });
-
-    const insertQuery = `INSERT INTO ${this.getTableNameExpression()} (${columnNames}) VALUES ${valuesExpressions.join(', ')}`;
-
-    return { insertQuery, values };
-  }
-
-  protected mapPlaceholderExpression(length: number, index: number, column: string) {
-    const exp = `$${length + index + 1}`;
-
-    const meta: TTableMeta = this.columns[column as keyof TEntity];
-    return meta.type === 'jsonb' ? exp : exp; // TODO: figure out how to handle this for postgres... $1::jsonb equivalent
-  }
-
-  protected buildSelectManyQuery(entities: Partial<TEntity>[]): { selectQuery: string, values: any[] } {
-    const keyMap: any = {};
-
-    entities.forEach(entity => {
-      Object.keys(entity)
-        .forEach(key => {
-          keyMap[key] = true;
-        });
-    });
-
-    const selectExpressions: string[] = [];
-    const values: any[] = [];
-
-    entities.forEach(entity => {
-      const length = values.length;
-
-      (Object.keys(keyMap) as Array<keyof Partial<TEntity>>).forEach(key => {
-        values.push((typeof entity[key] === 'undefined') ? this.columns[key].default : entity[key]);
-      });
-
-      const whereExpression = Object.keys(keyMap).map((_, index) => `(${(this.columns as any)[_].databasePath} = $${length + index + 1})`).join(' AND ');
-
-      selectExpressions.push(`(select * from ${this.getTableNameExpression()} where (${whereExpression}))`);
-    });
-
-    const selectQuery = selectExpressions.join(' UNION ');
-
-    return { selectQuery, values };
-  }
-
-  map(raw: any): TEntity {
-    const mapped = (Object.values(this.columns) as TTableMeta[])
-      .reduce((entity: any, { propertyPath, databasePath }: TTableMeta) => {
-        entity[propertyPath] = raw[databasePath];
-        return entity;
-      }, {} as any) as TEntity;
-
-    return mapped;
-  }
-
-  async query(query: string, parameters: any[]) {
-    if (this.debug) {
-      console.log({ schema: this.schema, table: this.table, query, parameters });
-    }
-
-    const result = await this.repo.query(query, parameters);
-
-    if (this.debug) {
-      console.log({ schema: this.schema, table: this.table, query, parameters, result });
-    }
-
-    return result as any[];
-  }
-
-  async queryAndMap(query: string, parameters: any[]) {
-    const result = await this.query(query, parameters);
-
-    return result?.map((_: any) => this.map(_)) as TEntity[];
-  }
-
-  static buildFromMetadata<TGenericEntity>(dataSource: DataSource, _: {schema: string, table: string, columns: TKeysOf<TGenericEntity, TTableMeta>}) {
-
-    class GenericRepository extends TypeOrmRepository<TGenericEntity> {
-      constructor() {
-        const entityManager = dataSource.createEntityManager();
-        super(Object, {
-          ...entityManager,
-          getRepository: () => entityManager as any
-        } as any);
-      }
-    }
-
-    const genericRepository = new GenericRepository();
-    (genericRepository as any).schema = _.schema;
-    (genericRepository as any).table = _.table;
-    (genericRepository as any).columns = _.columns;
-
-    return genericRepository as TypeOrmRepository<TGenericEntity>;
-  }
-
-
-  buildWhereILike(filters?: Record<string, any>): FindOptionsWhere<TEntity> {
-
-    if(!filters) {
-      return {};
-    }
-
-    return Object.entries(filters || {})
-      .reduce(
-        (_, [column, filter]) => (
-          filter
-            ? { ..._, [column]: ILike(`%${filter}%`) }
-            : _
-        ),
-        {}
-      ) as any;
-  }
-}

package/src/lib/constants/many-to-one-relation-options.constant.ts

@@ -1,3 +0,0 @@
-import { RelationOptions } from "typeorm";
-
-export const manyToOneRelationOptions: RelationOptions = { cascade: true, onDelete: 'CASCADE', orphanedRowAction: 'delete', onUpdate: 'CASCADE' };

package/src/lib/decorators/nullable-table-column.decorator.ts

@@ -1,9 +0,0 @@
-import { applyDecorators } from "@nestjs/common";
-import { Column, ColumnOptions } from "typeorm";
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import { getApiTypeFromColumn } from "../functions/get-api-type-from-column.function";
-
-export const NullableTableColumn = (options?: Pick<ColumnOptions, 'type'>) => {
-    const apiType = getApiTypeFromColumn(options?.type);
-    return applyDecorators(Column({ type: options?.type, nullable: true }), ApiPropertyOptional({type: apiType}));
-};

package/src/lib/decorators/primary-table-column.decorator.ts

@@ -1,9 +0,0 @@
-import { applyDecorators } from "@nestjs/common";
-import { Column, ColumnOptions } from "typeorm";
-import { ApiProperty } from '@nestjs/swagger';
-import { getApiTypeFromColumn } from "../functions/get-api-type-from-column.function";
-
-export const PrimaryTableColumn = (options?: Pick<ColumnOptions, 'type'>) => {
-    const apiType = getApiTypeFromColumn(options?.type);
-    return applyDecorators(Column({ type: options?.type, nullable: false }), ApiProperty({type: apiType}));
-};

package/src/lib/decorators/table-column.decorator.ts

@@ -1,9 +0,0 @@
-import { applyDecorators } from "@nestjs/common";
-import { Column, ColumnOptions } from "typeorm";
-import { ApiProperty } from '@nestjs/swagger';
-import { getApiTypeFromColumn } from "../functions/get-api-type-from-column.function";
-
-export const TableColumn = (options?: Pick<ColumnOptions, 'type'>) => {
-    const apiType = getApiTypeFromColumn(options?.type);
-    return applyDecorators(Column({ type: options?.type, nullable: false }), ApiProperty({type: apiType}));
-};

package/src/lib/decorators/table.decorator.ts

@@ -1,8 +0,0 @@
-import { applyDecorators } from "@nestjs/common";
-import { Entity } from "typeorm";
-import { snakeCase } from '@onivoro/isomorphic-common';
-
-export const Table = (EntityClass: { name: string }) => {
-    const tableName = snakeCase(EntityClass.name);
-    return applyDecorators(Entity(tableName));
-};

package/src/lib/functions/data-source-config-factory.function.ts

@@ -1,34 +0,0 @@
-import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
-import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions';
-import { IDataSourceOptions } from '../types/data-source-options.interface';
-
-export function dataSourceConfigFactory(
-  name: string,
-  options: IDataSourceOptions,
-  entities: any[]
-): PostgresConnectionOptions {
-
-  const {
-    ca, database, host, password, port, username, synchronize = false, logging = false, schema,
-  } = options;
-
-  const config: PostgresConnectionOptions = {
-    name,
-    type: 'postgres',
-    host,
-    port: port as any,
-    username,
-    password,
-    ssl: ca ? { ca } : undefined,
-    database,
-    synchronize,
-    logging,
-    entities,
-    schema,
-    subscribers: [],
-    migrations: [],
-    namingStrategy: new SnakeNamingStrategy(),
-  };
-
-  return config;
-}

package/src/lib/functions/data-source-factory.function.ts

@@ -1,10 +0,0 @@
-import { DataSource } from 'typeorm';
-import { dataSourceConfigFactory } from './data-source-config-factory.function';
-import { IDataSourceOptions } from '../types/data-source-options.interface';
-
-export const dataSourceFactory = (
-  name: string,
-  options: IDataSourceOptions,
-  entities: any[]
-) =>
-  new DataSource(dataSourceConfigFactory(name, options, entities));

package/src/lib/functions/generate-date-query.function.ts

@@ -1,20 +0,0 @@
-import { Between, FindOperator, LessThanOrEqual, MoreThanOrEqual } from "typeorm";
-
-export function generateDateQuery(
-    minDueDate: string,
-    maxDueDate: string
-): FindOperator<Date> | undefined {
-    if (minDueDate && maxDueDate) {
-        return Between(minDueDate as any, maxDueDate as any);
-    }
-
-    if (maxDueDate) {
-        return LessThanOrEqual(new Date(maxDueDate));
-    }
-
-    if (minDueDate) {
-        return MoreThanOrEqual(new Date(minDueDate));
-    }
-
-    return undefined;
-}

package/src/lib/functions/get-api-type-from-column.function.ts

@@ -1,14 +0,0 @@
-import { ColumnOptions } from "typeorm";
-
-export function getApiTypeFromColumn(columnType: ColumnOptions['type']) {
-    if(!columnType) {
-        return 'string';
-    }
-
-    switch (columnType) {
-        case 'boolean':
-            return columnType;
-        default:
-            return 'string';
-    }
-}

package/src/lib/functions/get-paging-key.function.ts

@@ -1,3 +0,0 @@
-export function getPagingKey(pageSize: number, skip: number, total: number) {
-  return pageSize * skip < total ? skip + 1 : undefined;
-}

package/src/lib/functions/get-skip.function.ts

@@ -1,3 +0,0 @@
-export function getSkip(pagingKey: number | string, pageSize: number) {
-  return pagingKey ? Number(pagingKey) * pageSize : 0;
-}

package/src/lib/functions/remove-falsey-keys.function.ts

@@ -1,8 +0,0 @@
-export function removeFalseyKeys<T extends Record<any, any>>(obj: T) {
-  return Object.entries(obj)
-    .filter(([k, v]) => typeof v !== 'undefined')
-    .reduce((acc, [k, v]) => {
-      (acc as any)[k] = v;
-      return acc;
-    }, {}) as T;
-}

package/src/lib/server-typeorm-postgres.module.ts

@@ -1,44 +0,0 @@
-import { DynamicModule, Module } from '@nestjs/common';
-import { DataSource, EntityManager } from 'typeorm';
-import { dataSourceFactory } from './functions/data-source-factory.function';
-import { IDataSourceOptions } from './types/data-source-options.interface';
-
-const dataSourceMap = new Map();
-
-@Module({})
-export class ServerTypeormPostgresModule {
-  static configure(
-    injectables: any[],
-    entities: any[],
-    options: IDataSourceOptions,
-    name = 'default'
-  ): DynamicModule {
-    const providers = [
-      {
-        provide: DataSource,
-        useFactory: async () => {
-          const cachedDataSource = dataSourceMap.get(name);
-          if (!cachedDataSource) {
-            const dataSource: DataSource = dataSourceFactory(name, options, entities);
-            await dataSource.initialize();
-            dataSourceMap.set(name, dataSource);
-          }
-          return dataSourceMap.get(name);
-        },
-      },
-      {
-        provide: EntityManager,
-        useFactory: (dataSource: DataSource) => {
-          return dataSource.manager;
-        },
-        inject: [DataSource]
-      },
-      ...injectables,
-    ];
-    return {
-      module: ServerTypeormPostgresModule,
-      exports: providers,
-      providers,
-    };
-  }
-}

package/src/lib/types/data-source-options.interface.ts

@@ -1,11 +0,0 @@
-export interface IDataSourceOptions {
-    database: string,
-    host: string,
-    port: string,
-    username: string,
-    password: string,
-    synchronize?: boolean,
-    logging?: boolean,
-    schema?: string,
-    ca?: string,
-}

package/src/lib/types/entity-provider.interface.ts

@@ -1,9 +0,0 @@
-export interface IEntityProvider<TEntity, TFindOneOptions, TFindManyOptions, TFindOptionsWhere, TQueryDeepPartialEntity> {
-    getOne: (options: TFindOneOptions) => Promise<TEntity>;
-    getMany: (options: TFindManyOptions) => Promise<TEntity[]>;
-    postOne: (body: Partial<TEntity>) => Promise<TEntity>;
-    postMany: (body: Partial<TEntity>[]) => Promise<TEntity[]>;
-    delete: (options: TFindOptionsWhere) => Promise<void>;
-    put: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
-    patch: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
-}

package/src/lib/types/page-params.interface.ts

@@ -1,6 +0,0 @@
-export interface IPageParams {
-    pagingKey: number;
-    pageSize: number;
-    sortKey?: string;
-    sortDirection?: string;
-}

package/src/lib/types/paged-data.interface.ts

@@ -1,6 +0,0 @@
-export interface IPagedData<TEntity> {
-    data: TEntity[];
-    total: number;
-    pagingKey: number;
-    pageSize: number;
-}

package/src/lib/types/table-meta.type.ts

@@ -1,4 +0,0 @@
-import { ColumnType } from "typeorm";
-import { ColumnMetadata } from "typeorm/metadata/ColumnMetadata.js";
-
-export type TTableMeta = { databasePath: string, type: ColumnType, propertyPath: string, isPrimary: boolean, default: ColumnMetadata['default'] };

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.server.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "strict": false
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "../../dist/libs/server/typeorm-postgres",
-    "declaration": true
-  },
-  "exclude": ["jest.config.ts", "**/*.spec.ts", "**/*.test.ts"],
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,21 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": [
-      "jest",
-      "node"
-    ]
-  },
-  "include": [
-    "jest.config.ts",
-    "**/*.test.ts",
-    "**/*.spec.ts",
-    "**/*.test.tsx",
-    "**/*.spec.tsx",
-    "**/*.test.js",
-    "**/*.spec.js",
-    "**/*.test.jsx",
-    "**/*.spec.jsx",
-    "**/*.d.ts"
-  ]
-}