@rws-framework/db 3.0.0 → 3.0.1

package/README.md

@@ -1,6 +1,6 @@
 # Models
 
-RWS models are converted to Prisma schemas and are wrapping around generated PrismaClient providing complete typing and better Relation handling + TimeSeries in future minor versions.
+RWS models are converted to Prisma schemas and are wrapping around generated PrismaClient providing complete typing and better Relation handling + TimeSeries in future versions.
 
 ## Models index file
 
@@ -21,11 +21,7 @@ export const models = [ User, ApiKey];
     import ApiKey from './ApiKey';
     import IApiKey from './interfaces/IApiKey';
 
-@RWSCollection('users', { 
-    relations: {
-        transcriptions: true,
-        apiKeys: true
-    },
+@RWSCollection('users', {
     ignored_keys: ['passwd']
 })
 class User extends RWSModel<User> implements IUser {
@@ -68,20 +64,26 @@ export default User;
 
 ***Basic many to one relation***
 ```typescript
-import { RWSModel, TrackType, Relation } from '@rws-framework/db';
+import { RWSCollection, RWSModel, TrackType, Relation } from '@rws-framework/db';
 
 import 'reflect-metadata';
 import User from './User';
+import SomeModel from './SomeModel';
 import IApiKey from './interfaces/IApiKey';
 
+@RWSCollection('user_api_keys', {
+    relations: {
+        dummyIgnoredHydrationRelation: false // ignoring this relation on hydration - will be null
+    }
+})
 class ApiKey extends RWSModel<ApiKey> implements IApiKey {
-    static _RELATIONS = {
-        user: true,
-    };
 
-    @Relation(() => User, true) // second attribute is required = false
+    @Relation(() => User, { requried: false }) // second attribute is required = false
     user: User;
 
+    @Relation(() => SomeModel) // relation to be ignored by 
+    dummyIgnoredHydrationRelation: SomeModel;
+
     @TrackType(Object)
     keyval: string;
 
@@ -111,29 +113,52 @@ export default ApiKey;
 
 ```typescript
 import 'reflect-metadata';
+import { RWSModel, OpModelType } from '../models/_model';
 
-import { RWSModel, OpModelType } from '@rws-framework/db';
+export type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
 
-interface IRelationOpts {
+export interface IRelationOpts {
     required?: boolean
-    key?: string
-    relationField?: string
-    relatedToField?: string
-    relatedTo: OpModelType<Model<any>>
+    key: string
+    relationField: string //name of field that will hold the relation key value
+    relatedToField?: string //name of related field (id by default)
+    mappingName?: string
+    relatedTo: OpModelType<RWSModel<any>>
+    many?: boolean // is it one-to-many or many-to-one
+    embed?: boolean // @deprecated for mongo - new decorator for embeds incoming
+    useUuid?: boolean //for sql dbs - if you're using some text based id
+    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>>, required: boolean = false, relationField: string = null, relatedToField: string = 'id') {
+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 metadataPromise = Promise.resolve().then(() => {            
             const relatedTo = theModel();
-            const metaOpts: IRelationOpts = {required, relatedTo, relatedToField};                    
-            if(!relationField){
-                metaOpts.relationField = relatedTo._collection + '_id';
-            } else{
-                metaOpts.relationField = relationField;
-            }  
-            metaOpts.key = key;
+
+            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;
         });
 
@@ -147,33 +172,41 @@ function Relation(theModel: () => OpModelType<RWSModel<any>>, required: boolean
 
 
 export default Relation;
-export {IRelationOpts};
+
+
 ```
 
 ***Inverse relation decorator*** (one-to-many)
 ```typescript
 import 'reflect-metadata';
-import { RWSModel, OpModelType } from '@rws-framework/db';
+import { RWSModel, OpModelType } from '../models/_model';
 
-interface InverseRelationOpts{
+export interface InverseRelationOpts {
     key: string,
-    inversionModel: OpModelType<RWSModel<any>>,
-    foreignKey: string    
-  }
+    inversionModel: OpModelType<RWSModel<any>>
+    foreignKey: string
+    singular?: boolean
+    relationName?: string
+    mappingName?: string
+}
 
-  function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, foreignKey: string = null) {    
-    return function(target: any, key: string) {     
-        // Store the promise in metadata immediately
+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: foreignKey ? foreignKey : `${source._collection}_id`
-            };             
-    
+                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;
         });
 
@@ -186,7 +219,7 @@ interface InverseRelationOpts{
 }
 
 export default InverseRelation;
-export {InverseRelationOpts};
+
 ```
 
 
@@ -307,99 +340,4 @@ bunx rws-db "mongodb://user:pass@localhost:27017/databaseName?authSource=admin&r
 
 Code for RWS to prisma conversion from "@rws-framework/server" package:
 
-```typescript
-static async generateModelSections(model: OpModelType<any>): Promise<string> {
-    let section = '';
-    const modelMetadatas: Record<string, {annotationType: string, metadata: any}> = await RWSModel.getModelAnnotations(model);    
-
-    const modelName: string = (model as any)._collection;
-    
-    section += `model ${modelName} {\n`;
-    section += '\tid String @map("_id") @id @default(auto()) @db.ObjectId\n';
-    
-    for (const key in modelMetadatas) {
-        const modelMetadata = modelMetadatas[key].metadata;            
-        let requiredString = modelMetadata.required ? '' : '?';  
-        const annotationType: string = modelMetadatas[key].annotationType;
-
-        if(key === 'id'){
-            continue;
-        }
-
-        
-        if(annotationType === 'Relation'){
-            const relationMeta = modelMetadata as IRelationOpts
-
-            const relatedModel = relationMeta.relatedTo as OpModelType<any>;  
-            const isMany = relationMeta.many;
-            const cascadeOpts = [];
-
-            if (relationMeta.cascade?.onDelete) {
-                cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
-            }
-
-            if (relationMeta.cascade?.onUpdate) {
-                cascadeOpts.push(`onUpdate: ${relationMeta.cascade.onUpdate}`);
-            }
-    
-            if (isMany) {
-                // Handle many-to-many or one-to-many relation
-                section += `\t${key} ${relatedModel._collection}[] @relation("${modelName}_${relatedModel._collection}")\n`;
-            } else {
-                // Handle one-to-one or many-to-one relation
-                section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField || 'id'}], ${cascadeOpts.join(', ')})\n`;
-                section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
-            }
-        } else if (annotationType === 'InverseRelation'){   
-            const relationMeta = modelMetadata as InverseRelationOpts;
-    
-            // Handle inverse relation (one-to-many or one-to-one)
-            section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${ relationMeta.relationName ? relationMeta.relationName : `${relationMeta.inversionModel._collection}_${modelName}`}")\n`;
-        } else if (annotationType === 'InverseTimeSeries'){        
-            section += `\t${key} String[] @db.ObjectId\n`;      
-        } else if (annotationType === 'TrackType'){        
-            const tags: string[] = modelMetadata.tags.map((item: string) => '@' + item);             
-
-            if(modelMetadata.isArray || modelMetadata.type.name === 'Array'){
-                requiredString = '';
-            }       
-            section += `\t${key} ${DbHelper.toConfigCase(modelMetadata)}${requiredString} ${tags.join(' ')}\n`;
-        }
-    }
-    
-    section += '}\n';
-    return section;
-}
-
-static toConfigCase(modelType: IMetaOpts): string {
-    const type = modelType.type;
-    let input = type.name;    
-    
-
-    if(input == 'Number'){
-        input = 'Int';
-    }
-
-    if(input == 'Object'){
-        input = 'Json';
-    }
-
-    if(input == 'Date'){
-        input = 'DateTime';
-    }
-
-    if(input == 'Array'){
-        input = 'Json[]';
-    }
-
-    const firstChar = input.charAt(0).toUpperCase();
-    const restOfString = input.slice(1);
-    let resultField = firstChar + restOfString;
-
-    if(modelType.isArray){
-        resultField += '[]';
-    }
-
-    return resultField;
-}
-```
+[The repo file](https://github.com/rws-framework/db/blob/master/src/helper/DbHelper.ts)

package/dist/helper/db/schema-generator.js

@@ -151,16 +151,28 @@ datasource db {
             else if (annotationType === 'TrackType') {
                 const trackMeta = modelMetadata;
                 const tags = trackMeta.tags.map((item) => '@' + item);
+                if (key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))) {
+                    continue;
+                }
                 if (trackMeta.unique) {
                     const fieldDetail = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
                 }
+                if (!trackMeta.required) {
+                    requiredString = '?';
+                }
                 if (trackMeta.isArray || trackMeta.type.name === 'Array') {
                     requiredString = '';
                 }
+                if (model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))) {
+                    requiredString = '';
+                }
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions(trackMeta, dbType);
                 tags.push(...dbSpecificTags);
+                if (modelName === 'category_translation' && key === 'meta_keywords') {
+                    console.log({ requiredString, trackMeta });
+                }
                 section += `\t${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
             }
         }

package/dist/models/core/RWSModel.d.ts

@@ -54,7 +54,7 @@ declare class RWSModel<T> implements IModel {
     sanitizeDBData(data: any): any;
     static watchCollection<T extends RWSModel<T>>(this: OpModelType<T>, preRun: () => void): Promise<any>;
     static findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
-    static find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    static find<T extends RWSModel<T>>(this: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
     static findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
     static delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;
     delete<T extends RWSModel<T>>(): Promise<void>;

package/dist/models/core/RWSModel.js

@@ -122,7 +122,8 @@ class RWSModel {
                     this[relMeta.key] = await newRelModel.save();
                 }
                 const cutKeys = this.constructor._CUT_KEYS;
-                if (!cutKeys.includes(relMeta.hydrationField)) {
+                const trackedField = Object.keys((await ModelUtils_1.ModelUtils.getModelAnnotations(this.constructor))).includes(relMeta.hydrationField);
+                if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
                     cutKeys.push(relMeta.hydrationField);
                 }
             }

package/dist/models/interfaces/OpModelType.d.ts

@@ -21,7 +21,7 @@ export interface OpModelType<T> {
     checkForInclusionWithThrow: (className: string) => void;
     checkForInclusion: (className: string) => boolean;
     findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
-    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
     findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
     paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
     delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/helper/db/schema-generator.ts

@@ -178,21 +178,37 @@ datasource db {
                 }
             } else if (annotationType === 'TrackType') {
                 const trackMeta = modelMetadata as ITrackerMetaOpts;
-                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);                           
+                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);  
+                
+                if(key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))){
+                    continue;
+                }
        
                 if(trackMeta.unique){
                     const fieldDetail: string | null = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
                 }
 
+                if(!trackMeta.required){
+                    requiredString = '?';
+                }
+
                 if (trackMeta.isArray || trackMeta.type.name === 'Array') {
                     requiredString = '';
                 }
 
+                if(model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))){
+                    requiredString = '';
+                }
+
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
                 tags.push(...dbSpecificTags);
 
+                if(modelName === 'category_translation' && key === 'meta_keywords'){
+                    console.log({requiredString, trackMeta});
+                }
+
                 section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
             }
         }

package/src/models/core/RWSModel.ts

@@ -113,7 +113,8 @@ class RWSModel<T> implements IModel {
         });      
     
         const seriesHydrationfields: string[] = []; 
-        
+
+
         if (allowRelations) {
             // Handle many-to-many relations
             for (const key in relManyData) { 
@@ -157,15 +158,17 @@ class RWSModel<T> implements IModel {
 
                 const cutKeys = ((this.constructor as any)._CUT_KEYS as string[]);
 
-                if(!cutKeys.includes(relMeta.hydrationField)){
+                const trackedField = Object.keys((await ModelUtils.getModelAnnotations(this.constructor as any))).includes(relMeta.hydrationField);
+                
+                if(!cutKeys.includes(relMeta.hydrationField) && !trackedField){
                     cutKeys.push(relMeta.hydrationField)
                 }
             }
         }
     
         // Process regular fields and time series
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {                        
+        for (const key in data) {         
+            if (data.hasOwnProperty(key)) {                   
                 if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
                     continue;
                 }
@@ -176,7 +179,8 @@ class RWSModel<T> implements IModel {
     
                 if (seriesHydrationfields.includes(key)) {
                     continue;
-                }                    
+                }                   
+              
     
                 const timeSeriesMetaData = timeSeriesIds[key];  
           
@@ -411,7 +415,7 @@ class RWSModel<T> implements IModel {
 
     public static async find<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        id: string,        
+        id: string | number,        
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | null> {        
         const ordering = findParams?.ordering ?? null;
@@ -445,12 +449,14 @@ class RWSModel<T> implements IModel {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);   
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);        
+
             if (dbData.length) {
                 const instanced: T[] = [];
         
                 for (const data of dbData) { 
                     const inst: T = new (this as { new(): T })();
+
                     instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
                 }
         

package/src/models/interfaces/OpModelType.ts

@@ -27,7 +27,7 @@ export interface OpModelType<T> {
     ): Promise<T | null>;
     find<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        id: string,        
+        id: string | number,        
         findParams?: Omit<FindByType, 'conditions'>
     ): Promise<T | null>;
     findBy<T extends RWSModel<T>>(