@rws-framework/db 2.3.2 → 2.4.0

package/dist/decorators/InverseRelation.d.ts

@@ -1,12 +1,12 @@
-import 'reflect-metadata';
-import { RWSModel, OpModelType } from '../models/_model';
-interface InverseRelationOpts {
-    key: string;
-    inversionModel: OpModelType<RWSModel<any>>;
-    foreignKey: string;
-    singular?: boolean;
-    relationName?: string;
-}
-declare function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<InverseRelationOpts>): (target: any, key: string) => void;
-export default InverseRelation;
-export { InverseRelationOpts };
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+interface InverseRelationOpts {
+    key: string;
+    inversionModel: OpModelType<RWSModel<any>>;
+    foreignKey: string;
+    singular?: boolean;
+    relationName?: string;
+}
+declare function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<InverseRelationOpts>): (target: any, key: string) => void;
+export default InverseRelation;
+export { InverseRelationOpts };

package/dist/decorators/InverseRelation.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
-    return function (target, key) {
-        const metadataPromise = Promise.resolve().then(() => {
-            const model = inversionModel();
-            const source = sourceModel();
-            const metaOpts = {
-                ...relationOptions,
-                key,
-                inversionModel: model,
-                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`
-            };
-            return metaOpts;
-        });
-        // Store both the promise and the key information
-        Reflect.defineMetadata(`InverseRelation:${key}`, {
-            promise: metadataPromise,
-            key
-        }, target);
-    };
-}
-exports.default = InverseRelation;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
+    return function (target, key) {
+        const metadataPromise = Promise.resolve().then(() => {
+            const model = inversionModel();
+            const source = sourceModel();
+            const metaOpts = {
+                ...relationOptions,
+                key,
+                inversionModel: model,
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`
+            };
+            return metaOpts;
+        });
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`InverseRelation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+exports.default = InverseRelation;

package/dist/decorators/InverseTimeSeries.d.ts

@@ -1,8 +1,8 @@
-import 'reflect-metadata';
-interface InverseTimeSeriesOpts {
-    timeSeriesModel: string;
-    hydrationField: string;
-}
-declare function InverseTimeSeries(timeSeriesModel: string, hydrationField: string): (target: any, key: string) => void;
-export default InverseTimeSeries;
-export { InverseTimeSeriesOpts };
+import 'reflect-metadata';
+interface InverseTimeSeriesOpts {
+    timeSeriesModel: string;
+    hydrationField: string;
+}
+declare function InverseTimeSeries(timeSeriesModel: string, hydrationField: string): (target: any, key: string) => void;
+export default InverseTimeSeries;
+export { InverseTimeSeriesOpts };

package/dist/decorators/InverseTimeSeries.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-function InverseTimeSeries(timeSeriesModel, hydrationField) {
-    const metaOpts = {
-        timeSeriesModel: timeSeriesModel,
-        hydrationField: hydrationField
-    };
-    return function (target, key) {
-        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
-    };
-}
-exports.default = InverseTimeSeries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function InverseTimeSeries(timeSeriesModel, hydrationField) {
+    const metaOpts = {
+        timeSeriesModel: timeSeriesModel,
+        hydrationField: hydrationField
+    };
+    return function (target, key) {
+        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
+    };
+}
+exports.default = InverseTimeSeries;

package/dist/decorators/RWSCollection.d.ts

@@ -1,12 +1,12 @@
-import { OpModelType } from "../models/_model";
-export interface IRWSCollectionOpts {
-    relations?: {
-        [key: string]: boolean;
-    };
-    ignored_keys?: string[];
-}
-export interface IRWSCollectionMeta {
-    collectionName: string;
-    options?: IRWSCollectionOpts;
-}
-export declare function RWSCollection(collectionName: string, options?: IRWSCollectionOpts): (target: OpModelType<any>) => void;
+import { OpModelType } from "../models/_model";
+export interface IRWSCollectionOpts {
+    relations?: {
+        [key: string]: boolean;
+    };
+    ignored_keys?: string[];
+}
+export interface IRWSCollectionMeta {
+    collectionName: string;
+    options?: IRWSCollectionOpts;
+}
+export declare function RWSCollection(collectionName: string, options?: IRWSCollectionOpts): (target: OpModelType<any>) => void;

package/dist/decorators/RWSCollection.js

@@ -1,16 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RWSCollection = RWSCollection;
-function RWSCollection(collectionName, options) {
-    const metaOpts = { collectionName, options };
-    return function (target) {
-        target._collection = collectionName;
-        if (options && options.relations) {
-            target._RELATIONS = options.relations;
-        }
-        if (options && options.ignored_keys) {
-            target._CUT_KEYS = options.ignored_keys;
-        }
-        Reflect.defineMetadata(`RWSCollection`, metaOpts, target);
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RWSCollection = RWSCollection;
+function RWSCollection(collectionName, options) {
+    const metaOpts = { collectionName, options };
+    return function (target) {
+        target._collection = collectionName;
+        if (options && options.relations) {
+            target._RELATIONS = options.relations;
+        }
+        if (options && options.ignored_keys) {
+            target._CUT_KEYS = options.ignored_keys;
+        }
+        Reflect.defineMetadata(`RWSCollection`, metaOpts, target);
+    };
+}

package/dist/decorators/Relation.d.ts

@@ -1,19 +1,19 @@
-import 'reflect-metadata';
-import { RWSModel, OpModelType } from '../models/_model';
-type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
-interface IRelationOpts {
-    required?: boolean;
-    key: string;
-    relationField: string;
-    relatedToField?: string;
-    relatedTo: OpModelType<RWSModel<any>>;
-    many?: boolean;
-    embed?: boolean;
-    cascade: {
-        onDelete: CascadingSetup;
-        onUpdate: CascadingSetup;
-    };
-}
-declare function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<IRelationOpts>): (target: any, key: string) => void;
-export default Relation;
-export { IRelationOpts };
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
+interface IRelationOpts {
+    required?: boolean;
+    key: string;
+    relationField: string;
+    relatedToField?: string;
+    relatedTo: OpModelType<RWSModel<any>>;
+    many?: boolean;
+    embed?: boolean;
+    cascade: {
+        onDelete: CascadingSetup;
+        onUpdate: CascadingSetup;
+    };
+}
+declare function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<IRelationOpts>): (target: any, key: string) => void;
+export default Relation;
+export { IRelationOpts };

package/dist/decorators/Relation.js

@@ -1,26 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const _DEFAULTS = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' } };
-function Relation(theModel, relationOptions = _DEFAULTS) {
-    return function (target, key) {
-        // Store the promise in metadata immediately
-        const metadataPromise = Promise.resolve().then(() => {
-            const relatedTo = theModel();
-            const metaOpts = {
-                ...relationOptions,
-                cascade: relationOptions.cascade || _DEFAULTS.cascade,
-                relatedTo,
-                relationField: relationOptions.relationField ? relationOptions.relationField : relatedTo._collection + '_id',
-                key
-            };
-            return metaOpts;
-        });
-        // Store both the promise and the key information
-        Reflect.defineMetadata(`Relation:${key}`, {
-            promise: metadataPromise,
-            key
-        }, target);
-    };
-}
-exports.default = Relation;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const _DEFAULTS = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' } };
+function Relation(theModel, relationOptions = _DEFAULTS) {
+    return function (target, key) {
+        // Store the promise in metadata immediately
+        const metadataPromise = Promise.resolve().then(() => {
+            const relatedTo = theModel();
+            const metaOpts = {
+                ...relationOptions,
+                cascade: relationOptions.cascade || _DEFAULTS.cascade,
+                relatedTo,
+                relationField: relationOptions.relationField ? relationOptions.relationField : relatedTo._collection + '_id',
+                key
+            };
+            return metaOpts;
+        });
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`Relation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+exports.default = Relation;

package/dist/decorators/TrackType.d.ts

@@ -1,20 +1,20 @@
-import 'reflect-metadata';
-import { OpModelType } from '../models/interfaces/OpModelType';
-interface ITrackerOpts {
-    required?: boolean;
-    isArray?: boolean;
-    relationField?: string;
-    relatedToField?: string;
-    relatedTo?: OpModelType<any>;
-    inversionModel?: OpModelType<any>;
-    relationName?: string;
-}
-interface IMetaOpts extends ITrackerOpts {
-    type: any;
-    tags: string[];
-    required: boolean;
-    isArray: boolean;
-}
-declare function TrackType(type: any, opts?: ITrackerOpts | null, tags?: string[]): (target: any, key: string) => void;
-export default TrackType;
-export { IMetaOpts, ITrackerOpts };
+import 'reflect-metadata';
+import { OpModelType } from '../models/interfaces/OpModelType';
+interface ITrackerOpts {
+    required?: boolean;
+    isArray?: boolean;
+    relationField?: string;
+    relatedToField?: string;
+    relatedTo?: OpModelType<any>;
+    inversionModel?: OpModelType<any>;
+    relationName?: string;
+}
+interface IMetaOpts extends ITrackerOpts {
+    type: any;
+    tags: string[];
+    required: boolean;
+    isArray: boolean;
+}
+declare function TrackType(type: any, opts?: ITrackerOpts | null, tags?: string[]): (target: any, key: string) => void;
+export default TrackType;
+export { IMetaOpts, ITrackerOpts };

package/dist/decorators/TrackType.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-function TrackType(type, opts = null, tags = []) {
-    if (!opts) {
-        opts = {
-            required: false,
-            isArray: false
-        };
-    }
-    if (!(opts === null || opts === void 0 ? void 0 : opts.required)) {
-        opts.required = false;
-    }
-    if (!(opts === null || opts === void 0 ? void 0 : opts.isArray)) {
-        opts.isArray = false;
-    }
-    const required = opts.required;
-    const isArray = opts.isArray;
-    const metaOpts = { type, tags, required, isArray };
-    if (opts.relatedToField && opts.relatedTo) {
-        metaOpts.relatedToField = opts.relatedToField;
-        metaOpts.relatedTo = opts.relatedTo;
-        if (!opts.relationField) {
-            metaOpts.relationField = opts.relatedTo + '_id';
-        }
-        else {
-            metaOpts.relationField = opts.relationField;
-        }
-    }
-    if (opts.inversionModel) {
-        metaOpts.inversionModel = opts.inversionModel;
-    }
-    //const resolvedType = typeof type === 'function' ? type() : type;   
-    if (type._collection) {
-        metaOpts.type = type;
-    }
-    return function (target, key) {
-        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
-    };
-}
-exports.default = TrackType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function TrackType(type, opts = null, tags = []) {
+    if (!opts) {
+        opts = {
+            required: false,
+            isArray: false
+        };
+    }
+    if (!(opts === null || opts === void 0 ? void 0 : opts.required)) {
+        opts.required = false;
+    }
+    if (!(opts === null || opts === void 0 ? void 0 : opts.isArray)) {
+        opts.isArray = false;
+    }
+    const required = opts.required;
+    const isArray = opts.isArray;
+    const metaOpts = { type, tags, required, isArray };
+    if (opts.relatedToField && opts.relatedTo) {
+        metaOpts.relatedToField = opts.relatedToField;
+        metaOpts.relatedTo = opts.relatedTo;
+        if (!opts.relationField) {
+            metaOpts.relationField = opts.relatedTo + '_id';
+        }
+        else {
+            metaOpts.relationField = opts.relationField;
+        }
+    }
+    if (opts.inversionModel) {
+        metaOpts.inversionModel = opts.inversionModel;
+    }
+    //const resolvedType = typeof type === 'function' ? type() : type;   
+    if (type._collection) {
+        metaOpts.type = type;
+    }
+    return function (target, key) {
+        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
+    };
+}
+exports.default = TrackType;

package/dist/decorators/index.d.ts

@@ -1,5 +1,5 @@
-import InverseRelation from './InverseRelation';
-import Relation from './Relation';
-import TrackType, { IMetaOpts } from './TrackType';
-import InverseTimeSeries from './InverseTimeSeries';
-export { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts };
+import InverseRelation from './InverseRelation';
+import Relation from './Relation';
+import TrackType, { IMetaOpts } from './TrackType';
+import InverseTimeSeries from './InverseTimeSeries';
+export { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts };

package/dist/decorators/index.js

@@ -1,14 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = void 0;
-const InverseRelation_1 = __importDefault(require("./InverseRelation"));
-exports.InverseRelation = InverseRelation_1.default;
-const Relation_1 = __importDefault(require("./Relation"));
-exports.Relation = Relation_1.default;
-const TrackType_1 = __importDefault(require("./TrackType"));
-exports.TrackType = TrackType_1.default;
-const InverseTimeSeries_1 = __importDefault(require("./InverseTimeSeries"));
-exports.InverseTimeSeries = InverseTimeSeries_1.default;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = void 0;
+const InverseRelation_1 = __importDefault(require("./InverseRelation"));
+exports.InverseRelation = InverseRelation_1.default;
+const Relation_1 = __importDefault(require("./Relation"));
+exports.Relation = Relation_1.default;
+const TrackType_1 = __importDefault(require("./TrackType"));
+exports.TrackType = TrackType_1.default;
+const InverseTimeSeries_1 = __importDefault(require("./InverseTimeSeries"));
+exports.InverseTimeSeries = InverseTimeSeries_1.default;

package/dist/helper/DbHelper.d.ts

@@ -1,8 +1,8 @@
-import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IMetaOpts, OpModelType } from '../models/_model';
-import { DBService } from '../services/DBService';
-export declare class DbHelper {
-    static installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
-    static generateModelSections(model: OpModelType<any>): Promise<string>;
-    static toConfigCase(modelType: IMetaOpts): string;
-}
+import { IDbConfigHandler } from '../types/DbConfigHandler';
+import { IMetaOpts, OpModelType } from '../models/_model';
+import { DBService } from '../services/DBService';
+export declare class DbHelper {
+    static installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    static generateModelSections(model: OpModelType<any>): Promise<string>;
+    static toConfigCase(modelType: IMetaOpts): string;
+}