@rws-framework/db 2.1.7 → 2.1.9

package/dist/decorators/InverseRelation.d.ts

@@ -4,7 +4,9 @@ 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>>, foreignKey?: string): (target: any, key: string) => void;
+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,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-function InverseRelation(inversionModel, sourceModel, foreignKey = null) {
+function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
     return function (target, key) {
-        // Store the promise in metadata immediately
         const metadataPromise = Promise.resolve().then(() => {
             const model = inversionModel();
             const source = sourceModel();
             const metaOpts = {
+                ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: foreignKey ? foreignKey : `${source._collection}_id`
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`
             };
             return metaOpts;
         });

package/dist/decorators/Relation.d.ts

@@ -1,12 +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;
+    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>>, required?: boolean, relationField?: string, relatedToField?: string): (target: any, key: string) => void;
+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,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-function Relation(theModel, required = false, relationField = null, relatedToField = 'id') {
+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 = { required, relatedTo, relatedToField };
-            if (!relationField) {
-                metaOpts.relationField = relatedTo._collection + '_id';
-            }
-            else {
-                metaOpts.relationField = relationField;
-            }
-            metaOpts.key = key;
+            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

package/dist/helper/DbHelper.js

@@ -29,7 +29,7 @@ class DbHelper {
             for (const model of dbModels) {
                 const modelSection = await DbHelper.generateModelSections(model);
                 template += '\n\n' + modelSection;
-                log('RWS SCHEMA BUILD', chalk_1.default.blue('Building DB Model'), model.name);
+                log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
                 if (_model_1.RWSModel.isSubclass(model, TimeSeriesModel_1.default)) {
                     dbService.collectionExists(model._collection).then((exists) => {
                         if (exists) {
@@ -51,8 +51,9 @@ class DbHelper {
             fs_1.default.writeFileSync(schemaPath, template);
             process.env.DB_URL = dbUrl;
             const endPrisma = 'npx prisma';
+            const clientPath = path_1.default.join(console_1.rwsPath.findRootWorkspacePath(), 'node_modules', '.prisma', 'client');
             await console_1.rwsShell.runCommand(`${endPrisma} generate --schema=${schemaPath}`, process.cwd());
-            // leaveFile = true;
+            leaveFile = true;
             log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
             if (!leaveFile) {
                 fs_1.default.unlinkSync(schemaPath);
@@ -60,6 +61,7 @@ class DbHelper {
         }
     }
     static async generateModelSections(model) {
+        var _a, _b;
         let section = '';
         const modelMetadatas = await _model_1.RWSModel.getModelAnnotations(model);
         const modelName = model._collection;
@@ -73,14 +75,30 @@ class DbHelper {
                 continue;
             }
             if (annotationType === 'Relation') {
-                const relatedModel = modelMetadata.relatedTo;
-                // Handle direct relation (many-to-one or one-to-one)
-                section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField}], onDelete: Cascade)\n`;
-                section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
+                const relationMeta = modelMetadata;
+                const relatedModel = relationMeta.relatedTo;
+                const isMany = relationMeta.many;
+                const cascadeOpts = [];
+                if ((_a = relationMeta.cascade) === null || _a === void 0 ? void 0 : _a.onDelete) {
+                    cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
+                }
+                if ((_b = relationMeta.cascade) === null || _b === void 0 ? void 0 : _b.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;
                 // Handle inverse relation (one-to-many or one-to-one)
-                section += `\t${key} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.inversionModel._collection}_${modelName}")\n`;
+                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`;
@@ -105,6 +123,9 @@ class DbHelper {
         if (input == 'Date') {
             return 'DateTime';
         }
+        if (input == 'Array') {
+            return 'Json';
+        }
         const firstChar = input.charAt(0).toUpperCase();
         const restOfString = input.slice(1);
         return firstChar + restOfString;

package/package.json

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

package/src/decorators/InverseRelation.ts

@@ -4,20 +4,22 @@ import { RWSModel, OpModelType } from '../models/_model';
 interface InverseRelationOpts{
     key: string,
     inversionModel: OpModelType<RWSModel<any>>,
-    foreignKey: string    
+    foreignKey: string,
+    singular?: boolean    
+    relationName?: 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`
             };             
     
             return metaOpts;

package/src/decorators/Relation.ts

@@ -1,26 +1,37 @@
 import 'reflect-metadata';
 import { RWSModel, OpModelType } from '../models/_model';
 
+type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
+
 interface IRelationOpts {
     required?: boolean
-    key?: string
-    relationField?: string
+    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>>, 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 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
+            };                                        
             return metaOpts;
         });
 

package/src/helper/DbHelper.ts

@@ -7,6 +7,8 @@ import { IDbConfigHandler } from '../types/DbConfigHandler';
 import { IMetaOpts, OpModelType, RWSModel } from '../models/_model';
 import TimeSeriesModel from '../models/TimeSeriesModel';
 import { DBService } from '../services/DBService';
+import { IRelationOpts } from '../decorators/Relation';
+import { InverseRelationOpts } from '../decorators/InverseRelation';
 
 const log = console.log;
 const workspaceRoot = rwsPath.findRootWorkspacePath();
@@ -36,7 +38,7 @@ export class DbHelper {
 
                 template += '\n\n' + modelSection;  
 
-                log('RWS SCHEMA BUILD', chalk.blue('Building DB Model'), model.name);
+                log(chalk.green('[RWS]'), chalk.blue('Building DB Model'), model.name);
             
                 if(RWSModel.isSubclass(model as any, TimeSeriesModel)){    
                     dbService.collectionExists(model._collection).then((exists: boolean) => {
@@ -65,9 +67,11 @@ export class DbHelper {
             fs.writeFileSync(schemaPath, template);  
             process.env.DB_URL = dbUrl;
             const endPrisma = 'npx prisma';
+
+            const clientPath = path.join(rwsPath.findRootWorkspacePath(), 'node_modules', '.prisma', 'client');
             await rwsShell.runCommand(`${endPrisma} generate --schema=${schemaPath}`, process.cwd());  
 
-            // leaveFile = true;
+            leaveFile = true;
             log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
 
             if(!leaveFile){
@@ -86,22 +90,43 @@ export class DbHelper {
         section += '\tid String @map("_id") @id @default(auto()) @db.ObjectId\n';
      
         for (const key in modelMetadatas) {
-            const modelMetadata: IMetaOpts = modelMetadatas[key].metadata;            
+            const modelMetadata = modelMetadatas[key].metadata;            
             const requiredString = modelMetadata.required ? '' : '?';  
             const annotationType: string = modelMetadatas[key].annotationType;
     
             if(key === 'id'){
                 continue;
             }
+
             
             if(annotationType === 'Relation'){
-                const relatedModel = modelMetadata.relatedTo as OpModelType<any>;        
-                // Handle direct relation (many-to-one or one-to-one)
-                section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${modelName}_${relatedModel._collection}", fields: [${modelMetadata.relationField}], references: [${modelMetadata.relatedToField}], onDelete: Cascade)\n`;      
-                section += `\t${modelMetadata.relationField} String${requiredString} @db.ObjectId\n`;
-            } else if (annotationType === 'InverseRelation'){        
+                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} ${modelMetadata.inversionModel._collection}[] @relation("${modelMetadata.inversionModel._collection}_${modelName}")\n`;
+                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'){        
@@ -129,6 +154,10 @@ export class DbHelper {
         if(input == 'Date'){
             return 'DateTime';
         }
+
+        if(input == 'Array'){
+            return 'Json';
+        }
     
     
         const firstChar = input.charAt(0).toUpperCase();