@rws-framework/db 2.3.2 → 2.4.1

package/src/decorators/InverseRelation.ts

@@ -1,37 +1,37 @@
-import 'reflect-metadata';
-import { RWSModel, OpModelType } from '../models/_model';
-
-interface InverseRelationOpts{
-    key: string,
-    inversionModel: OpModelType<RWSModel<any>>,
-    foreignKey: string,
-    singular?: boolean    
-    relationName?: string
-  }
-
-  function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<InverseRelationOpts> = null) {    
-    return function(target: any, key: string) {             
-        const metadataPromise = Promise.resolve().then(() => {
-            const model = inversionModel();
-            const source = sourceModel();
-    
-            const metaOpts: InverseRelationOpts = {
-                ...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);
-    };
-}
-
-export default InverseRelation;
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+
+interface InverseRelationOpts{
+    key: string,
+    inversionModel: OpModelType<RWSModel<any>>,
+    foreignKey: string,
+    singular?: boolean    
+    relationName?: string
+  }
+
+  function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<InverseRelationOpts> = null) {    
+    return function(target: any, key: string) {             
+        const metadataPromise = Promise.resolve().then(() => {
+            const model = inversionModel();
+            const source = sourceModel();
+    
+            const metaOpts: InverseRelationOpts = {
+                ...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);
+    };
+}
+
+export default InverseRelation;
 export {InverseRelationOpts};

package/src/decorators/InverseTimeSeries.ts

@@ -1,22 +1,22 @@
-import 'reflect-metadata';
-
-interface InverseTimeSeriesOpts{
-    timeSeriesModel: string
-    hydrationField: string
-  }
-  
-function InverseTimeSeries(timeSeriesModel: string, hydrationField: string) {
-
-    const metaOpts: InverseTimeSeriesOpts = {
-        timeSeriesModel: timeSeriesModel,
-        hydrationField: hydrationField
-    };
-
-
-    return function(target: any, key: string) {          
-        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
-    };
-}
-
-export default InverseTimeSeries;
+import 'reflect-metadata';
+
+interface InverseTimeSeriesOpts{
+    timeSeriesModel: string
+    hydrationField: string
+  }
+  
+function InverseTimeSeries(timeSeriesModel: string, hydrationField: string) {
+
+    const metaOpts: InverseTimeSeriesOpts = {
+        timeSeriesModel: timeSeriesModel,
+        hydrationField: hydrationField
+    };
+
+
+    return function(target: any, key: string) {          
+        Reflect.defineMetadata(`InverseTimeSeries:${key}`, metaOpts, target);
+    };
+}
+
+export default InverseTimeSeries;
 export {InverseTimeSeriesOpts};

package/src/decorators/RWSCollection.ts

@@ -1,28 +1,28 @@
-import { OpModelType } from "../models/_model";
-
-export interface IRWSCollectionOpts {
-    relations?: {
-        [key: string]: boolean
-    },
-    ignored_keys?: string[]
-}
-
-export interface IRWSCollectionMeta {
-    collectionName: string,
-    options?: IRWSCollectionOpts
-}
-
-  
-export function RWSCollection(collectionName: string, options?: IRWSCollectionOpts) {
-    const metaOpts: IRWSCollectionMeta = { collectionName, options };
-    return function(target: OpModelType<any>) {     
-        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);
-    };
+import { OpModelType } from "../models/_model";
+
+export interface IRWSCollectionOpts {
+    relations?: {
+        [key: string]: boolean
+    },
+    ignored_keys?: string[]
+}
+
+export interface IRWSCollectionMeta {
+    collectionName: string,
+    options?: IRWSCollectionOpts
+}
+
+  
+export function RWSCollection(collectionName: string, options?: IRWSCollectionOpts) {
+    const metaOpts: IRWSCollectionMeta = { collectionName, options };
+    return function(target: OpModelType<any>) {     
+        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/src/decorators/Relation.ts

@@ -1,48 +1,48 @@
-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
-    }
-}
-
-const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' }};
-  
-function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<IRelationOpts> = _DEFAULTS) {
-    return function(target: any, key: string) {     
-        // Store the promise in metadata immediately
-        const metadataPromise = Promise.resolve().then(() => {
-            const relatedTo = theModel();
-
-            const metaOpts: IRelationOpts = {
-                ...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);
-    };
-}
-
-
-export default Relation;
+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
+    }
+}
+
+const _DEFAULTS: Partial<IRelationOpts> = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' }};
+  
+function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<IRelationOpts> = _DEFAULTS) {
+    return function(target: any, key: string) {     
+        // Store the promise in metadata immediately
+        const metadataPromise = Promise.resolve().then(() => {
+            const relatedTo = theModel();
+
+            const metaOpts: IRelationOpts = {
+                ...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);
+    };
+}
+
+
+export default Relation;
 export {IRelationOpts};

package/src/decorators/TrackType.ts

@@ -1,69 +1,69 @@
-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
-  }
-  
-function TrackType(type: any, opts: ITrackerOpts | null = null, tags: string[] = []) {
-    if(!opts){
-        opts = {
-            required: false,
-            isArray: false
-        };
-    }
-    
-    if(!opts?.required){
-        opts.required = false;
-    }
-
-    if(!opts?.isArray){
-        opts.isArray = false;
-    }
-  
-    const required = opts.required;
-    const isArray = opts.isArray;
-  
-    const metaOpts: IMetaOpts = {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 as any);
-    }
-  
-    return function(target: any, key: string) {          
-        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
-    };
-}
-
-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
+  }
+  
+function TrackType(type: any, opts: ITrackerOpts | null = null, tags: string[] = []) {
+    if(!opts){
+        opts = {
+            required: false,
+            isArray: false
+        };
+    }
+    
+    if(!opts?.required){
+        opts.required = false;
+    }
+
+    if(!opts?.isArray){
+        opts.isArray = false;
+    }
+  
+    const required = opts.required;
+    const isArray = opts.isArray;
+  
+    const metaOpts: IMetaOpts = {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 as any);
+    }
+  
+    return function(target: any, key: string) {          
+        Reflect.defineMetadata(`TrackType:${key}`, metaOpts, target);
+    };
+}
+
+export default TrackType;
+export {IMetaOpts, ITrackerOpts};

package/src/decorators/index.ts

@@ -1,8 +1,8 @@
-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
 };