@rws-framework/db 3.11.0 → 3.12.0

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

@@ -11,6 +11,7 @@ const _model_1 = require("../../models/_model");
 const utils_1 = require("./utils");
 const type_converter_1 = require("./type-converter");
 const relation_manager_1 = require("./relation-manager");
+const child_process_1 = require("child_process");
 const _EXECUTE_PRISMA_CMD = true;
 const _REMOVE_SCHEMA_FILE = true;
 /**
@@ -339,8 +340,23 @@ datasource db {
      */
     static async pushDBModels(configService, dbService, leaveFile = false) {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+        console.log({ env: process.env.PRISMA_DB_URL });
         const [_, schemaPath] = utils_1.DbUtils.getProcessedSchemaDir();
-        await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
+        const prismaPath = require.resolve('prisma/build/index.js');
+        // Set environment variables
+        const env = {
+            ...process.env,
+            [this.dbUrlVarName]: configService.get('db_url')
+        };
+        // Execute prisma db push programmatically
+        (0, child_process_1.execSync)(`node ${prismaPath} db push --schema=${schemaPath} --force-reset`, {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            env
+        });
+        // await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd(), false, { env: {
+        //     PRISMA_DB_URL: configService.get('db_url')
+        // }});
     }
 }
 exports.SchemaGenerator = SchemaGenerator;

package/dist/models/core/RWSModel.js

@@ -140,18 +140,38 @@ class RWSModel {
         const data = {};
         const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields = [];
+        // Get relation metadata to determine how to handle each relation
+        const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
+        const relOneData = await this.getRelationOneMeta(classFields);
         for (const key in this) {
             if (await this.hasRelation(key)) {
-                if (this[key] === null) {
-                    // For null relations, use disconnect or set to null
-                    data[key] = {
-                        disconnect: true
-                    };
-                }
-                else {
-                    data[key] = this.bindRelation(key, this[key]);
+                const relationMeta = relOneData[key];
+                if (relationMeta) {
+                    // Use connect on relations that are either:
+                    // 1. Required (required: true)
+                    // 2. Have explicitly set cascade options (metaOpts.cascade)
+                    const hasExplicitCascade = relationMeta.cascade && Object.keys(relationMeta.cascade).length > 0;
+                    const shouldUseConnect = relationMeta.required || hasExplicitCascade;
+                    if (shouldUseConnect) {
+                        // Relations with required=true or explicit cascade → use connect
+                        if (this[key] === null) {
+                            data[key] = { disconnect: true };
+                        }
+                        else if (this[key] && this[key].id) {
+                            data[key] = { connect: { id: this[key].id } };
+                        }
+                    }
+                    else {
+                        // Simple optional relations → use foreign key field directly
+                        const foreignKeyField = relationMeta.hydrationField;
+                        if (this[key] === null) {
+                            data[foreignKeyField] = null;
+                        }
+                        else if (this[key] && this[key].id) {
+                            data[foreignKeyField] = this[key].id;
+                        }
+                    }
                 }
-                // Don't try to set the foreign key directly anymore
                 continue;
             }
             if (!(await this.isDbVariable(key))) {

package/dist/models/types/RelationTypes.d.ts

@@ -12,6 +12,10 @@ export type RelOneMetaType<T extends IRWSModel> = {
         model: OpModelType<T>;
         hydrationField: string;
         foreignKey: string;
+        cascade?: {
+            onDelete?: string;
+            onUpdate?: string;
+        };
     };
 };
 export type RelManyMetaType<T extends IRWSModel> = {

package/dist/models/utils/RelationUtils.js

@@ -19,7 +19,8 @@ class RelationUtils {
                         required: resolvedMetadata.required,
                         model: resolvedMetadata.relatedTo,
                         hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
+                        foreignKey: resolvedMetadata.relatedToField,
+                        cascade: resolvedMetadata.cascade
                     };
                 }
             }

package/package.json

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

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

@@ -14,6 +14,7 @@ import { TypeConverter } from './type-converter';
 import { RelationManager } from './relation-manager';
 import { ITrackerMetaOpts } from '../../decorators/TrackType';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
+import { execSync } from 'child_process';
 
 const _EXECUTE_PRISMA_CMD = true;
 const _REMOVE_SCHEMA_FILE = true;
@@ -444,8 +445,27 @@ datasource db {
     static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
 
+        console.log({ env: process.env.PRISMA_DB_URL });
+
         const [_, schemaPath] = DbUtils.getProcessedSchemaDir();
 
-        await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
+         const prismaPath = require.resolve('prisma/build/index.js');
+                    
+        // Set environment variables
+        const env = {
+            ...process.env,            
+            [this.dbUrlVarName]: configService.get('db_url')
+        };
+
+        // Execute prisma db push programmatically
+        execSync(`node ${prismaPath} db push --schema=${schemaPath} --force-reset`, {
+            cwd: process.cwd(),
+            stdio: 'inherit',
+            env
+        });
+
+        // await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd(), false, { env: {
+        //     PRISMA_DB_URL: configService.get('db_url')
+        // }});
     }
 }

package/src/models/core/RWSModel.ts

@@ -179,19 +179,40 @@ class RWSModel<T> implements IModel {
         const data: any = {};
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields: string[] = [];
+        
+        // Get relation metadata to determine how to handle each relation
+        const classFields = FieldsHelper.getAllClassFields(this.constructor);
+        const relOneData = await this.getRelationOneMeta(classFields);
       
         for (const key in (this as any)) { 
-            if (await this.hasRelation(key)) {                
-                if (this[key] === null) {
-                    // For null relations, use disconnect or set to null
-                    data[key] = {
-                        disconnect: true
-                    };
-                } else {
-                    data[key] = this.bindRelation(key, this[key]);  
+            if (await this.hasRelation(key)) {
+                const relationMeta = relOneData[key];
+                
+                if (relationMeta) {
+                    // Use connect on relations that are either:
+                    // 1. Required (required: true)
+                    // 2. Have explicitly set cascade options (metaOpts.cascade)
+                    const hasExplicitCascade = relationMeta.cascade && Object.keys(relationMeta.cascade).length > 0;
+                    const shouldUseConnect = relationMeta.required || hasExplicitCascade;
+                    
+                    if (shouldUseConnect) {
+                        // Relations with required=true or explicit cascade → use connect
+                        if (this[key] === null) {
+                            data[key] = { disconnect: true };
+                        } else if (this[key] && this[key].id) {
+                            data[key] = { connect: { id: this[key].id } };                            
+                        }
+                    } else {
+                        // Simple optional relations → use foreign key field directly
+                        const foreignKeyField = relationMeta.hydrationField;
+                        if (this[key] === null) {
+                            data[foreignKeyField] = null;
+                        } else if (this[key] && this[key].id) {
+                            data[foreignKeyField] = this[key].id;
+                        }
+                    }
                 }
                 
-                // Don't try to set the foreign key directly anymore
                 continue;
             }
     

package/src/models/types/RelationTypes.ts

@@ -12,7 +12,11 @@ export type RelOneMetaType<T extends IRWSModel> = {
         key?: string, 
         model: OpModelType<T>, 
         hydrationField: string, 
-        foreignKey: string
+        foreignKey: string,
+        cascade?: {
+            onDelete?: string,
+            onUpdate?: string
+        }
     }
 };
 

package/src/models/utils/RelationUtils.ts

@@ -23,7 +23,8 @@ export class RelationUtils {
                         required: resolvedMetadata.required,
                         model: resolvedMetadata.relatedTo,
                         hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
+                        foreignKey: resolvedMetadata.relatedToField,
+                        cascade: resolvedMetadata.cascade
                     };
                 }
             }