@rws-framework/db 2.4.6 → 3.0.1

package/src/decorators/IdType.ts

@@ -0,0 +1,17 @@
+import 'reflect-metadata';
+import { ITrackerOpts } from '../models/interfaces/ITrackerOpts';
+import { IIdTypeOpts } from '../models/interfaces/IIdTypeOpts';
+  
+export interface IIdMetaOpts extends IIdTypeOpts {
+    type: any,
+}
+  
+function IdType(type: any, opts: IIdTypeOpts | null = null, tags: string[] = []) {   
+    const metaOpts: IIdMetaOpts = { type, dbOptions: opts && opts.dbOptions ? opts.dbOptions : null };
+    return function(target: any, key: string) {          
+        Reflect.defineMetadata(`IdType:${key}`, metaOpts, target);
+    };
+}
+
+export default IdType;
+export { IIdTypeOpts};

package/src/decorators/InverseRelation.ts

@@ -1,37 +1,41 @@
-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};
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+
+export interface InverseRelationOpts {
+    key: string,
+    inversionModel: OpModelType<RWSModel<any>>
+    foreignKey: string
+    singular?: boolean
+    relationName?: string
+    mappingName?: 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`,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions && relationOptions.relationName ?
+                    relationOptions.relationName.toLowerCase() :
+                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
+            };
+
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`InverseRelation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+export default InverseRelation;

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,46 @@
-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";
+
+
+//@todo Replace with source
+export interface ISuperTagData {
+    tagType: string,
+    fields: string[],
+    map: string
+}
+
+export interface IRWSCollectionOpts {
+    relations?: {
+        [key: string]: boolean
+    },
+    ignored_keys?: string[],
+    noId?: boolean,
+    superTags?: ISuperTagData[]
+}
+
+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;
+        }
+
+        if(options && options.noId){
+            target._NO_ID = options.noId;
+        }
+
+        if(options && options.superTags && options.superTags.length){
+            target._SUPER_TAGS = options.superTags;
+        }
+
+        Reflect.defineMetadata(`RWSCollection`, metaOpts, target);
+    };
 } 

package/src/decorators/Relation.ts

@@ -1,48 +1,61 @@
-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};
+import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
+
+export type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
+
+export interface IRelationOpts {
+    required?: boolean
+    key: string
+    relationField: string
+    relatedToField?: string
+    mappingName?: string
+    relatedTo: OpModelType<RWSModel<any>>
+    many?: boolean
+    embed?: boolean
+    useUuid?: boolean
+    relationName?: string
+    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,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions.relationName ? 
+                  relationOptions.relationName.toLowerCase() : 
+                  `${target.constructor.name.toLowerCase()}_${key}_${relatedTo._collection.toLowerCase()}`
+            };  
+            
+            if(relationOptions.required){
+                metaOpts.cascade.onDelete = 'Restrict';
+            }
+
+            return metaOpts;
+        });
+
+        // Store both the promise and the key information
+        Reflect.defineMetadata(`Relation:${key}`, {
+            promise: metadataPromise,
+            key
+        }, target);
+    };
+}
+
+
+export default Relation;
+

package/src/decorators/TrackType.ts

@@ -1,69 +1,65 @@
-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 { ITrackerOpts } from '../models/interfaces/ITrackerOpts';
+  
+export interface ITrackerMetaOpts extends ITrackerOpts{
+    type: any,
+    tags: string[],
+}
+  
+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: ITrackerMetaOpts = {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;  
+    }
+    
+    // Copy dbOptions if present
+    if(opts.dbOptions){
+        metaOpts.dbOptions = opts.dbOptions;
+    }
+
+    if(opts.unique){
+        metaOpts.unique = opts.unique;
+    }
+  
+    //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;

package/src/decorators/index.ts

@@ -1,8 +1,16 @@
-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, { ITrackerMetaOpts } from './TrackType';
+import InverseTimeSeries from './InverseTimeSeries';
+import IdType from './IdType';
+import { ITrackerOpts } from '../models/interfaces/ITrackerOpts';
+
+export {
+    InverseRelation,
+    Relation,
+    TrackType,
+    IdType,
+    InverseTimeSeries,
+    ITrackerMetaOpts,
+    ITrackerOpts
+};