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

package/README.md

@@ -1,4 +1,4 @@
 # Node-C / Persistance: RDB
-This is Node-C's package providing the functionality for relational databases. Currently, PostgreSQL and MySQL are supported.
+This is Node-C's package providing the functionality for relational databases that TypeORMDB can work with. Currently, PostgreSQL and MySQL are supported.
 
 The documentation can be found on the [Node-C Github repo homepage](https://github.com/RazorDude/node-c).

package/dist/common/definitions/common.constants.d.ts

@@ -1,4 +1,8 @@
 export declare enum Constants {
+    RDB_ENTITY_REPOSITORY = "RDB_ENTITY_REPOSITORY",
+    RDB_REPOSITORY_CONNECTION_NAME = "RDB_REPOSITORY_CONNECTION_NAME",
+    RDB_REPOSITORY_DATASOURCE = "RDB_REPOSITORY_DATASOURCE",
+    RDB_REPOSITORY_ENTITY_CLASS = "RDB_REPOSITORY_ENTITY_CLASS",
     SQL_BUILDER_DB_CONFIG_PATH = "SQL_BUILDER_DB_CONFIG_PATH",
     SQL_BUILDER_SERVICE_TOKEN_SUFFIX = "_SQL_BUILDER_SERVICE"
 }

package/dist/common/definitions/common.constants.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constants = void 0;
 var Constants;
 (function (Constants) {
+    Constants["RDB_ENTITY_REPOSITORY"] = "RDB_ENTITY_REPOSITORY";
+    Constants["RDB_REPOSITORY_CONNECTION_NAME"] = "RDB_REPOSITORY_CONNECTION_NAME";
+    Constants["RDB_REPOSITORY_DATASOURCE"] = "RDB_REPOSITORY_DATASOURCE";
+    Constants["RDB_REPOSITORY_ENTITY_CLASS"] = "RDB_REPOSITORY_ENTITY_CLASS";
     Constants["SQL_BUILDER_DB_CONFIG_PATH"] = "SQL_BUILDER_DB_CONFIG_PATH";
     Constants["SQL_BUILDER_SERVICE_TOKEN_SUFFIX"] = "_SQL_BUILDER_SERVICE";
 })(Constants || (exports.Constants = Constants = {}));

package/dist/common/definitions/common.constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.constants.js","sourceRoot":"","sources":["../../../src/common/definitions/common.constants.ts"],"names":[],"mappings":";;;AAAA,IAAY,SAKX;AALD,WAAY,SAAS;IAEnB,sEAAyD,CAAA;IAEzD,sEAAyD,CAAA;AAC3D,CAAC,EALW,SAAS,yBAAT,SAAS,QAKpB"}
+{"version":3,"file":"common.constants.js","sourceRoot":"","sources":["../../../src/common/definitions/common.constants.ts"],"names":[],"mappings":";;;AAAA,IAAY,SAaX;AAbD,WAAY,SAAS;IAEnB,4DAA+C,CAAA;IAE/C,8EAAiE,CAAA;IAEjE,oEAAuD,CAAA;IAEvD,wEAA2D,CAAA;IAE3D,sEAAyD,CAAA;IAEzD,sEAAyD,CAAA;AAC3D,CAAC,EAbW,SAAS,yBAAT,SAAS,QAapB"}

package/dist/{entityService → entity}/index.d.ts

@@ -1,2 +1,3 @@
-export * from './rdb.entity.service.definitions';
+export * from './rdb.entity.schema';
 export * from './rdb.entity.service';
+export * from './rdb.entity.service.definitions';

package/dist/{entityService → entity}/index.js

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

package/dist/entity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/entity/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC;AACpC,uDAAqC;AACrC,mEAAiD"}

package/dist/entity/rdb.entity.schema.d.ts

@@ -0,0 +1,18 @@
+export type RDBEntityRelationType = 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
+export interface RDBEntitySchema {
+    options: {
+        columns: {
+            [columnName: string]: {
+                deleteDate?: boolean;
+                name?: string;
+                primary?: boolean;
+            } | undefined;
+        };
+        relations?: {
+            [relationName: string]: {
+                target: string | unknown;
+                type: RDBEntityRelationType;
+            } | undefined;
+        };
+    };
+}

package/dist/{module/rdb.module.definitions.js → entity/rdb.entity.schema.js}

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

package/dist/entity/rdb.entity.schema.js.map

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

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

@@ -0,0 +1,42 @@
+import { ConfigProviderService, GenericObject, PersistanceDeleteResult, PersistanceEntityService, PersistanceFindResults, PersistanceRelationItem, PersistanceUpdateResult } from '@node-c/core';
+import { RDBEntitySchema } from './rdb.entity.schema';
+import { BulkCreateOptions, BulkCreatePrivateOptions, CountOptions, CountPrivateOptions, CreateOptions, CreatePrivateOptions, DefaultData, DeleteOptions, DeletePrivateOptions, FindOneOptions, FindOnePrivateOptions, FindOptions, FindPrivateOptions, ProcessManyToManyColumnSettingsItem, UpdateOptions, UpdatePrivateOptions } from './rdb.entity.service.definitions';
+import { RDBEntityManager, RDBRepository } from '../repository';
+import { ParsedFilter, SQLQueryBuilderService } from '../sqlQueryBuilder';
+export declare class RDBEntityService<Entity extends GenericObject<unknown>, Data extends DefaultData<Entity> = DefaultData<Entity>> extends PersistanceEntityService<Entity> {
+    protected configProvider: ConfigProviderService;
+    protected qb: SQLQueryBuilderService;
+    protected repository: RDBRepository<Entity>;
+    protected schema: RDBEntitySchema;
+    protected columnAliases: Record<string, string>;
+    protected columNames: string[];
+    protected deletedColumnName?: string;
+    protected primaryKeys: string[];
+    constructor(configProvider: ConfigProviderService, qb: SQLQueryBuilderService, repository: RDBRepository<Entity>, schema: RDBEntitySchema);
+    protected buildPrimaryKeyWhereClause(data: Entity[]): {
+        field: string;
+        value: ParsedFilter;
+    };
+    bulkCreate(data: Data['BulkCreate'], options?: BulkCreateOptions, privateOptions?: BulkCreatePrivateOptions): Promise<Entity[]>;
+    count(options: CountOptions, privateOptions?: CountPrivateOptions): Promise<number | undefined>;
+    create(data: Data['Create'], options?: CreateOptions, privateOptions?: CreatePrivateOptions): Promise<Entity>;
+    delete(options: DeleteOptions, privateOptions?: DeletePrivateOptions): Promise<PersistanceDeleteResult<Entity>>;
+    find(options: FindOptions, privateOptions?: FindPrivateOptions): Promise<PersistanceFindResults<Entity>>;
+    findOne(options: FindOneOptions, privateOptions?: FindOnePrivateOptions): Promise<Entity | null>;
+    getEntityTarget(): unknown;
+    protected getRepository(transactionManager?: RDBEntityManager): RDBRepository<Entity>;
+    protected processManyToMany<RelationItemsData>(data: {
+        counterpartColumns: ProcessManyToManyColumnSettingsItem[];
+        currentEntityColumns: ProcessManyToManyColumnSettingsItem[];
+        currentEntityItems: Entity[];
+        extraColumns?: ProcessManyToManyColumnSettingsItem[];
+        items: PersistanceRelationItem<RelationItemsData>[];
+        tableName: string;
+    }, options?: {
+        transactionManager?: RDBEntityManager;
+    }): Promise<void>;
+    protected save<Data = unknown, ReturnData = unknown>(data: Data, transactionManager?: RDBEntityManager, options?: {
+        processObjectAllowedFieldsEnabled?: boolean;
+    }): Promise<ReturnData>;
+    update(data: Data['Update'], options: UpdateOptions, privateOptions?: UpdatePrivateOptions): Promise<PersistanceUpdateResult<Entity>>;
+}

package/dist/entity/rdb.entity.service.definitions.d.ts

@@ -0,0 +1,41 @@
+import { PersistanceBulkCreatePrivateOptions, PersistanceCountOptions, PersistanceCountPrivateOptions, PersistanceCreatePrivateOptions, PersistanceDeleteOptions, PersistanceDeletePrivateOptions, PersistanceFindOneOptions, PersistanceFindOnePrivateOptions, PersistanceFindOptions, PersistanceFindPrivateOptions, PersistanceUpdateOptions, PersistanceUpdatePrivateOptions } from '@node-c/core';
+import { RDBEntityManager } from '../repository';
+export interface BaseOptions {
+    forceTransaction?: boolean;
+    transactionManager?: RDBEntityManager;
+}
+export type BulkCreateOptions = BaseOptions;
+export type BulkCreatePrivateOptions = PersistanceBulkCreatePrivateOptions;
+export interface CountOptions extends BaseOptions, PersistanceCountOptions {
+}
+export type CountPrivateOptions = PersistanceCountPrivateOptions;
+export type CreateOptions = BaseOptions;
+export type CreatePrivateOptions = PersistanceCreatePrivateOptions;
+export interface DefaultData<Entity> {
+    BulkCreate: Partial<Entity>[];
+    Create: Partial<Entity>;
+    Update: Partial<Entity>;
+}
+export interface DeleteOptions extends BaseOptions, PersistanceDeleteOptions {
+}
+export type DeletePrivateOptions = PersistanceDeletePrivateOptions;
+export interface FindOneOptions extends BaseOptions, PersistanceFindOneOptions {
+}
+export type FindOnePrivateOptions = PersistanceFindOnePrivateOptions;
+export interface FindOptions extends BaseOptions, PersistanceFindOptions {
+}
+export type FindPrivateOptions = PersistanceFindPrivateOptions;
+export declare enum PostgresErrorCode {
+    UniqueViolation = "23505"
+}
+export interface ProcessManyToManyColumnSettingsItem {
+    sourceColumnName: string;
+    targetColumnName?: string;
+}
+export interface ProcessRelationsDataOptions<Entity> {
+    currentEntityItem: Entity;
+    transactionManager?: RDBEntityManager;
+}
+export interface UpdateOptions extends BaseOptions, PersistanceUpdateOptions {
+}
+export type UpdatePrivateOptions = PersistanceUpdatePrivateOptions;

package/dist/entity/rdb.entity.service.definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rdb.entity.service.definitions.js","sourceRoot":"","sources":["../../src/entity/rdb.entity.service.definitions.ts"],"names":[],"mappings":";;;AAoDA,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAE3B,8CAAyB,CAAA;AAC3B,CAAC,EAHW,iBAAiB,iCAAjB,iBAAiB,QAG5B"}