@onivoro/server-typeorm-postgres 22.0.12 → 22.0.13

package/dist/cjs/index.d.ts

@@ -0,0 +1,28 @@
+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/dist/cjs/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./lib/classes/column-migration-base.class"), exports);
+__exportStar(require("./lib/classes/columns-migration-base.class"), exports);
+__exportStar(require("./lib/classes/drop-column-migration-base.class"), exports);
+__exportStar(require("./lib/classes/drop-table-migration-base.class"), exports);
+__exportStar(require("./lib/classes/index-migration-base.class"), exports);
+__exportStar(require("./lib/classes/redshift-repository.class"), exports);
+__exportStar(require("./lib/classes/sql-writer.class"), exports);
+__exportStar(require("./lib/classes/table-migration-base.class"), exports);
+__exportStar(require("./lib/classes/type-orm-paging-repository.class"), exports);
+__exportStar(require("./lib/classes/type-orm-repository.class"), exports);
+__exportStar(require("./lib/constants/many-to-one-relation-options.constant"), exports);
+__exportStar(require("./lib/decorators/nullable-table-column.decorator"), exports);
+__exportStar(require("./lib/decorators/primary-table-column.decorator"), exports);
+__exportStar(require("./lib/decorators/table-column.decorator"), exports);
+__exportStar(require("./lib/decorators/table.decorator"), exports);
+__exportStar(require("./lib/functions/data-source-config-factory.function"), exports);
+__exportStar(require("./lib/functions/data-source-factory.function"), exports);
+__exportStar(require("./lib/functions/generate-date-query.function"), exports);
+__exportStar(require("./lib/functions/get-api-type-from-column.function"), exports);
+__exportStar(require("./lib/functions/get-paging-key.function"), exports);
+__exportStar(require("./lib/functions/get-skip.function"), exports);
+__exportStar(require("./lib/functions/remove-falsey-keys.function"), exports);
+__exportStar(require("./lib/types/data-source-options.interface"), exports);
+__exportStar(require("./lib/types/entity-provider.interface"), exports);
+__exportStar(require("./lib/types/page-params.interface"), exports);
+__exportStar(require("./lib/types/paged-data.interface"), exports);
+__exportStar(require("./lib/types/table-meta.type"), exports);
+__exportStar(require("./lib/server-typeorm-postgres.module"), exports);

package/dist/cjs/lib/classes/column-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class ColumnMigrationBase implements MigrationInterface {
+    table: string;
+    option: TableColumnOptions;
+    constructor(table: string, option: TableColumnOptions);
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/column-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class ColumnMigrationBase {
+    table;
+    option;
+    constructor(table, option) {
+        this.table = table;
+        this.option = option;
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.addColumn(this.table, this.option));
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropColumn(this.table, this.option));
+    }
+}
+exports.ColumnMigrationBase = ColumnMigrationBase;

package/dist/cjs/lib/classes/columns-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class ColumnsMigrationBase implements MigrationInterface {
+    table: string;
+    options: TableColumnOptions[];
+    constructor(table: string, options: TableColumnOptions[]);
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/columns-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnsMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class ColumnsMigrationBase {
+    table;
+    options;
+    constructor(table, options) {
+        this.table = table;
+        this.options = options;
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.addColumns(this.table, this.options));
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropColumns(this.table, this.options));
+    }
+}
+exports.ColumnsMigrationBase = ColumnsMigrationBase;

package/dist/cjs/lib/classes/drop-column-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class DropColumnMigrationBase implements MigrationInterface {
+    table: string;
+    option: TableColumnOptions;
+    constructor(table: string, option: TableColumnOptions);
+    down(queryRunner: QueryRunner): Promise<void>;
+    up(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/drop-column-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropColumnMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class DropColumnMigrationBase {
+    table;
+    option;
+    constructor(table, option) {
+        this.table = table;
+        this.option = option;
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.addColumn(this.table, this.option));
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropColumn(this.table, this.option));
+    }
+}
+exports.DropColumnMigrationBase = DropColumnMigrationBase;

package/dist/cjs/lib/classes/drop-table-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class DropTableMigrationBase implements MigrationInterface {
+    table: string;
+    options: TableColumnOptions[];
+    constructor(table: string, options: TableColumnOptions[]);
+    down(queryRunner: QueryRunner): Promise<void>;
+    up(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/drop-table-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTableMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class DropTableMigrationBase {
+    table;
+    options;
+    constructor(table, options) {
+        this.table = table;
+        this.options = options;
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.createTable(this.table, this.options));
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropTable(this.table));
+    }
+}
+exports.DropTableMigrationBase = DropTableMigrationBase;

package/dist/cjs/lib/classes/index-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class UniqueIndexMigrationBase implements MigrationInterface {
+    table: string;
+    option: TableColumnOptions;
+    constructor(table: string, option: TableColumnOptions);
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/index-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueIndexMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class UniqueIndexMigrationBase {
+    table;
+    option;
+    constructor(table, option) {
+        this.table = table;
+        this.option = option;
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.createUniqueIndex(this.table, this.option.name));
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropIndex(sql_writer_class_1.SqlWriter.getIndexName(this.table, this.option.name)));
+    }
+}
+exports.UniqueIndexMigrationBase = UniqueIndexMigrationBase;

package/dist/cjs/lib/classes/redshift-repository.class.d.ts

@@ -0,0 +1,29 @@
+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';
+export declare class RedshiftRepository<TEntity> extends TypeOrmRepository<TEntity> {
+    entityType: any;
+    entityManager: EntityManager;
+    constructor(entityType: any, entityManager: EntityManager);
+    getMany(options: FindManyOptions<TEntity>): Promise<TEntity[]>;
+    getOne(options: FindOneOptions<TEntity>): Promise<TEntity>;
+    delete(where: FindOptionsWhere<TEntity>): Promise<void>;
+    patch(where: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void>;
+    postOne(entity: Partial<TEntity>): Promise<TEntity>;
+    postMany(entities: Partial<TEntity>[]): Promise<TEntity[]>;
+    put(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void>;
+    forTransaction(entityManager: EntityManager): TypeOrmRepository<TEntity>;
+    getManyAndCount(options: FindManyOptions<TEntity>): Promise<[TEntity[], number]>;
+    softDelete(where: FindOptionsWhere<TEntity>): Promise<void>;
+    postOneWithoutReturn(entity: Partial<TEntity>): Promise<void>;
+    postManyWithoutReturn(entities: Partial<TEntity>[]): Promise<void>;
+    private throwNotImplemented;
+    protected mapPlaceholderExpression(length: number, index: number, column: string): string;
+    static buildFromMetadata<TGenericEntity>(dataSource: DataSource, _: {
+        schema: string;
+        table: string;
+        columns: TKeysOf<TGenericEntity, TTableMeta>;
+    }): RedshiftRepository<TGenericEntity>;
+}

package/dist/cjs/lib/classes/redshift-repository.class.js

@@ -0,0 +1,129 @@
+"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 RedshiftRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedshiftRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const type_orm_repository_class_1 = require("./type-orm-repository.class");
+let RedshiftRepository = RedshiftRepository_1 = class RedshiftRepository extends type_orm_repository_class_1.TypeOrmRepository {
+    entityType;
+    entityManager;
+    constructor(entityType, entityManager) {
+        super(entityType, entityManager);
+        this.entityType = entityType;
+        this.entityManager = entityManager;
+    }
+    async getMany(options) {
+        const { query, queryParams } = this.buildSelectStatement(options);
+        return await this.queryAndMap(query, queryParams.map(_ => _.value ? _.value : _));
+    }
+    async getOne(options) {
+        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];
+    }
+    async delete(where) {
+        const { query, queryParams } = this.buildDeleteStatement(where);
+        await this.query(query, queryParams);
+    }
+    async patch(where, body) {
+        const queryParams = [];
+        let whereClause = '';
+        Object.entries(where).forEach(([propertyPath, value], index) => {
+            const key = this.columns[propertyPath].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 = [];
+        let setExpressions = [];
+        const length = queryParams?.length;
+        Object.entries(body).forEach(([key, value], index) => {
+            setExpressions.push(`${this.columns[key].databasePath} = ${this.mapPlaceholderExpression(length, index, key)}`);
+            setParams.push(value);
+        });
+        let query = `UPDATE ${this.getTableNameExpression()} SET ${setExpressions.join(', ')} ${whereClause}`;
+        await this.query(query, [...queryParams, ...setParams]);
+    }
+    async postOne(entity) {
+        await this.postOneWithoutReturn(entity);
+        return await this.getOne({ where: entity });
+    }
+    async postMany(entities) {
+        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 [];
+    }
+    async put(options, body) {
+        this.throwNotImplemented('put');
+    }
+    forTransaction(entityManager) {
+        this.throwNotImplemented('forTransaction');
+        return this;
+    }
+    async getManyAndCount(options) {
+        this.throwNotImplemented('getManyAndCount');
+        return [[], 0];
+    }
+    async softDelete(where) {
+        await this.patch(where, { deletedAt: new Date().toISOString() });
+    }
+    async postOneWithoutReturn(entity) {
+        // PERFORM AN INSERT BUT NOT THE RETRIEVAL QUERY FOR PERFORMANCE
+        const { insertQuery, values } = this.buildInsertQuery(entity);
+        await this.query(insertQuery, values);
+    }
+    async postManyWithoutReturn(entities) {
+        // TODO: PERFORM AN INSERT BUT NOT THE RETRIEVAL QUERY FOR PERFORMANCE
+        // TODO: THIS IS ACTUALLY NEEDED TO HELP WITH LARGE DATASETS
+        this.throwNotImplemented('postManyWithoutReturn');
+    }
+    throwNotImplemented(feature) {
+        throw new common_1.NotImplementedException(`RedshiftRepository of type "${this.entityType?.name}" has no implementation for "${feature}"`);
+    }
+    mapPlaceholderExpression(length, index, column) {
+        const exp = `$${length + index + 1}`;
+        const meta = this.columns[column];
+        return meta.type === 'jsonb' ? `JSON_PARSE(${exp})` : exp;
+    }
+    static buildFromMetadata(dataSource, _) {
+        class GenericRepository extends RedshiftRepository_1 {
+            constructor() {
+                const entityManager = dataSource.createEntityManager();
+                super(Object, {
+                    ...entityManager,
+                    getRepository: () => entityManager
+                });
+            }
+        }
+        const genericRepository = new GenericRepository();
+        genericRepository.schema = _.schema;
+        genericRepository.table = _.table;
+        genericRepository.columns = _.columns;
+        return genericRepository;
+    }
+};
+exports.RedshiftRepository = RedshiftRepository;
+exports.RedshiftRepository = RedshiftRepository = RedshiftRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, typeorm_1.EntityManager])
+], RedshiftRepository);

package/dist/cjs/lib/classes/sql-writer.class.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnOptions } from "typeorm";
+export declare class SqlWriter {
+    static addColumn(table: string, option: TableColumnOptions): string;
+    static createTable(table: string, options: TableColumnOptions[]): string;
+    static dropTable(table: string): string;
+    static addColumns(table: string, options: TableColumnOptions[]): string;
+    static dropColumn(table: string, option: TableColumnOptions): string;
+    static dropColumns(table: string, options: TableColumnOptions[]): string;
+    static dropIndex(index: string): string;
+    static createIndex(table: string, column: string, unique: boolean): string;
+    static getIndexName(table: string, column: string): string;
+    static createUniqueIndex(table: string, column: string): string;
+    static getDefaultValueExpression(option: TableColumnOptions): string;
+}

package/dist/cjs/lib/classes/sql-writer.class.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlWriter = void 0;
+class SqlWriter {
+    static addColumn(table, option) {
+        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}`;
+    }
+    static createTable(table, options) {
+        const cols = options.map(option => SqlWriter.addColumn(table, option).replace(`ALTER TABLE "${table}" ADD `, '')).join(',\n');
+        return `CREATE TABLE "${table}" (${cols});`;
+    }
+    static dropTable(table) {
+        return `DROP TABLE "${table}";\n`;
+    }
+    static addColumns(table, options) {
+        return options.map(option => SqlWriter.addColumn(table, option)).join('; \n');
+    }
+    static dropColumn(table, option) {
+        return `ALTER TABLE "${table}" DROP COLUMN ${option.name}`;
+    }
+    static dropColumns(table, options) {
+        return options.map(option => SqlWriter.dropColumn(table, option)).join('; \n');
+    }
+    static dropIndex(index) {
+        return `DROP INDEX IF EXISTS ${index}`;
+    }
+    static createIndex(table, column, unique) {
+        const index = SqlWriter.getIndexName(table, column);
+        return `CREATE ${unique ? 'UNIQUE' : ''} INDEX IF NOT EXISTS ${index} ON "${table}"(${column})`;
+    }
+    static getIndexName(table, column) {
+        return `${table}_${column}`;
+    }
+    static createUniqueIndex(table, column) {
+        return SqlWriter.createIndex(table, column, true);
+    }
+    static getDefaultValueExpression(option) {
+        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}' `;
+    }
+}
+exports.SqlWriter = SqlWriter;

package/dist/cjs/lib/classes/table-migration-base.class.d.ts

@@ -0,0 +1,8 @@
+import { MigrationInterface, QueryRunner, TableColumnOptions } from "typeorm";
+export declare class TableMigrationBase implements MigrationInterface {
+    table: string;
+    options: TableColumnOptions[];
+    constructor(table: string, options: TableColumnOptions[]);
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/cjs/lib/classes/table-migration-base.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableMigrationBase = void 0;
+const sql_writer_class_1 = require("./sql-writer.class");
+class TableMigrationBase {
+    table;
+    options;
+    constructor(table, options) {
+        this.table = table;
+        this.options = options;
+    }
+    async up(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.createTable(this.table, this.options));
+    }
+    async down(queryRunner) {
+        await queryRunner.query(sql_writer_class_1.SqlWriter.dropTable(this.table));
+    }
+}
+exports.TableMigrationBase = TableMigrationBase;

package/dist/cjs/lib/classes/type-orm-paging-repository.class.d.ts

@@ -0,0 +1,14 @@
+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 declare abstract class TypeOrmPagingRepository<TEntity, TEntityParams> extends TypeOrmRepository<TEntity> {
+    protected getPagingKey: typeof getPagingKey;
+    protected getSkip: typeof getSkip;
+    protected removeFalseyKeys: typeof removeFalseyKeys;
+    constructor(entityType: any, entityManager: EntityManager);
+    abstract getPage(pageParams: IPageParams, params: TEntityParams): Promise<IPagedData<TEntity>>;
+}

package/dist/cjs/lib/classes/type-orm-paging-repository.class.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmPagingRepository = void 0;
+const type_orm_repository_class_1 = require("./type-orm-repository.class");
+const get_skip_function_1 = require("../functions/get-skip.function");
+const remove_falsey_keys_function_1 = require("../functions/remove-falsey-keys.function");
+const get_paging_key_function_1 = require("../functions/get-paging-key.function");
+class TypeOrmPagingRepository extends type_orm_repository_class_1.TypeOrmRepository {
+    getPagingKey = get_paging_key_function_1.getPagingKey;
+    getSkip = get_skip_function_1.getSkip;
+    removeFalseyKeys = remove_falsey_keys_function_1.removeFalseyKeys;
+    constructor(entityType, entityManager) {
+        super(entityType, entityManager);
+    }
+}
+exports.TypeOrmPagingRepository = TypeOrmPagingRepository;

package/dist/cjs/lib/classes/type-orm-repository.class.d.ts

@@ -0,0 +1,62 @@
+import { DataSource, EntityManager, FindManyOptions, FindOneOptions, FindOptionsWhere } 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 declare class TypeOrmRepository<TEntity> implements IEntityProvider<TEntity, FindOneOptions<TEntity>, FindManyOptions<TEntity>, FindOptionsWhere<TEntity>, QueryDeepPartialEntity<TEntity>> {
+    entityType: any;
+    entityManager: EntityManager;
+    columns: TKeysOf<TEntity, TTableMeta>;
+    table: string;
+    schema: string;
+    debug: boolean;
+    constructor(entityType: any, entityManager: EntityManager);
+    forTransaction(entityManager: EntityManager): TypeOrmRepository<TEntity>;
+    getMany(options: FindManyOptions<TEntity>): Promise<TEntity[]>;
+    getManyAndCount(options: FindManyOptions<TEntity>): Promise<[TEntity[], number]>;
+    getOne(options: FindOneOptions<TEntity>): Promise<TEntity>;
+    postOne(body: Partial<TEntity>): Promise<TEntity>;
+    postMany(body: Partial<TEntity>[]): Promise<TEntity[]>;
+    delete(options: FindOptionsWhere<TEntity>): Promise<void>;
+    softDelete(options: FindOptionsWhere<TEntity>): Promise<void>;
+    put(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void>;
+    patch(options: FindOptionsWhere<TEntity>, body: QueryDeepPartialEntity<TEntity>): Promise<void>;
+    get repo(): import("typeorm").Repository<import("typeorm").ObjectLiteral>;
+    protected insertAndReturn(entityToInsert: TEntity): Promise<TEntity>;
+    protected insertAndReturnMany(entitiesToInsert: TEntity[]): Promise<TEntity[]>;
+    protected getSchemaPrefix(): string;
+    protected getTableNameExpression(): string;
+    protected buildSelectStatement(options: FindManyOptions<TEntity>): {
+        query: string;
+        queryParams: any[];
+    };
+    protected buildDeleteStatement(where: FindManyOptions<TEntity>): {
+        query: string;
+        queryParams: any[];
+    };
+    protected buildWhereExpression(where?: FindOptionsWhere<TEntity>): {
+        queryParams: any[];
+        whereClause: string;
+    };
+    protected buildInsertQuery(entity: Partial<TEntity>): {
+        insertQuery: string;
+        values: any[];
+    };
+    protected buildInsertManyQuery(entities: Partial<TEntity>[]): {
+        insertQuery: string;
+        values: any[];
+    };
+    protected mapPlaceholderExpression(length: number, index: number, column: string): string;
+    protected buildSelectManyQuery(entities: Partial<TEntity>[]): {
+        selectQuery: string;
+        values: any[];
+    };
+    map(raw: any): TEntity;
+    query(query: string, parameters: any[]): Promise<any[]>;
+    queryAndMap(query: string, parameters: any[]): Promise<TEntity[]>;
+    static buildFromMetadata<TGenericEntity>(dataSource: DataSource, _: {
+        schema: string;
+        table: string;
+        columns: TKeysOf<TGenericEntity, TTableMeta>;
+    }): TypeOrmRepository<TGenericEntity>;
+}