@rws-framework/db 3.3.0 → 3.3.2

package/dist/helper/DbHelper.js

@@ -34,7 +34,7 @@ class DbHelper {
     }
     static async migrateDBModels(configService, dbService, leaveFile = false) {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
-        const [_, schemaPath] = db_1.DbUtils.getSchemaDir();
+        const [_, schemaPath] = db_1.DbUtils.getProcessedSchemaDir();
         await console_1.rwsShell.runCommand(`${db_1.DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
     }
     /**

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

@@ -109,9 +109,15 @@ datasource db {
                             requiredString = '';
                         }
                         let relatedFieldType = type_converter_1.TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
+                        /**
+                         * @todo: Detect type
+                         */
                         if (relatedToField === 'id' && dbType !== 'mongodb') {
                             relatedFieldType = 'Int';
                         }
+                        if (relationMeta.required === false) {
+                            requiredString = '?';
+                        }
                         // Add relation field with appropriate type based on database
                         if (dbType === 'mongodb') {
                             section += `\t${relationFieldName} String${requiredString} @db.ObjectId\n`;
@@ -298,7 +304,7 @@ datasource db {
      */
     static async pushDBModels(configService, dbService, leaveFile = false) {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
-        const [_, schemaPath] = utils_1.DbUtils.getSchemaDir();
+        const [_, schemaPath] = utils_1.DbUtils.getProcessedSchemaDir();
         await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
     }
 }

package/dist/helper/db/utils.d.ts

@@ -8,6 +8,7 @@ export declare class DbUtils {
      * Get the directory and path for the Prisma schema file
      */
     static getSchemaDir(): [string, string];
+    static getProcessedSchemaDir(): [string, string];
     /**
      * Detect the package installer (yarn or npx)
      */

package/dist/helper/db/utils.js

@@ -22,6 +22,11 @@ class DbUtils {
         const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
         return [schemaDir, schemaPath];
     }
+    static getProcessedSchemaDir() {
+        const schemaDir = path_1.default.join(workspaceRoot, 'node_modules', '.prisma', 'client');
+        const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
+        return [schemaDir, schemaPath];
+    }
     /**
      * Detect the package installer (yarn or npx)
      */

package/dist/models/utils/RelationUtils.js

@@ -58,8 +58,23 @@ class RelationUtils {
         return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
     }
     static checkRelDisabled(model, key) {
-        return Object.keys(model.constructor._RELATIONS).includes(key) &&
-            model.constructor._RELATIONS[key] === false;
+        const constructor = model.constructor;
+        let declaredRelations = [];
+        for (const relKey in constructor._RELATIONS) {
+            const relEntry = constructor._RELATIONS[relKey];
+            if (relEntry === true) {
+                declaredRelations.push(relKey);
+            }
+        }
+        // if((model.constructor as OpModelType<any>)._collection === 'product'){
+        //     console.log({key, declaredRelations});
+        //  }         
+        // A relation disabled through declared relations
+        if (declaredRelations.length && !declaredRelations.includes(key)) {
+            return true;
+        }
+        // A relation disabled directly
+        return Object.keys(constructor._RELATIONS).includes(key) && constructor._RELATIONS[key] === false;
     }
 }
 exports.RelationUtils = RelationUtils;

package/package.json

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

package/src/helper/DbHelper.ts

@@ -46,7 +46,7 @@ export class DbHelper {
     static async migrateDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
        
-        const [_, schemaPath] = DbUtils.getSchemaDir();
+        const [_, schemaPath] = DbUtils.getProcessedSchemaDir();
 
         await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
     }

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

@@ -146,9 +146,16 @@ datasource db {
                         
                         let relatedFieldType = TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
         
+                        /**
+                         * @todo: Detect type
+                         */
                         if(relatedToField === 'id' && dbType !== 'mongodb'){
                             relatedFieldType = 'Int';
-                        }                                       
+                        }                                      
+                        
+                        if(relationMeta.required === false){
+                            requiredString = '?';
+                        }
                     
                         // Add relation field with appropriate type based on database
                         if (dbType === 'mongodb') {
@@ -383,7 +390,7 @@ datasource db {
     static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
 
-        const [_, schemaPath] = DbUtils.getSchemaDir();
+        const [_, schemaPath] = DbUtils.getProcessedSchemaDir();
 
         await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
     }

package/src/helper/db/utils.ts

@@ -24,6 +24,13 @@ export class DbUtils {
         return [schemaDir, schemaPath];
     }
 
+    static getProcessedSchemaDir(): [string, string] {
+        const schemaDir = path.join(workspaceRoot, 'node_modules','.prisma', 'client');
+        const schemaPath = path.join(schemaDir, 'schema.prisma');
+
+        return [schemaDir, schemaPath];
+    }
+
     /**
      * Detect the package installer (yarn or npx)
      */

package/src/models/utils/HydrateUtils.ts

@@ -55,6 +55,9 @@ export class HydrateUtils {
                  const relMeta = relManyData[key];  
          
                  const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+
+                       
+
                  if (relationEnabled) {                                
                     model[relMeta.key] = await relMeta.inversionModel.findBy({
                          conditions: {

package/src/models/utils/RelationUtils.ts

@@ -1,6 +1,6 @@
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { IRWSModel } from '../../types/IRWSModel';
-import { RWSModel } from '../_model';
+import { OpModelType, RWSModel } from '../_model';
 
 export class RelationUtils {
     static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
@@ -70,7 +70,28 @@ export class RelationUtils {
     }
 
     static checkRelDisabled(model: RWSModel<any>, key: string): boolean {
-        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
-               (model.constructor as any)._RELATIONS[key] === false;
+        const constructor = model.constructor as OpModelType<any>;
+
+        let declaredRelations: string[] = [];
+
+        for(const relKey in constructor._RELATIONS){
+            const relEntry = constructor._RELATIONS[relKey];
+
+            if(relEntry === true){
+                declaredRelations.push(relKey);
+            }
+        }
+
+        // if((model.constructor as OpModelType<any>)._collection === 'product'){
+        //     console.log({key, declaredRelations});
+        //  }         
+
+        // A relation disabled through declared relations
+        if(declaredRelations.length && !declaredRelations.includes(key)){
+            return true;
+        }
+
+        // A relation disabled directly
+        return Object.keys(constructor._RELATIONS).includes(key) && constructor._RELATIONS[key] === false;
     }
 }