@solidstarters/solid-core 1.2.204 → 1.2.207

package/src/dtos/create-role-metadata.dto.ts

@@ -6,6 +6,10 @@ import { UpdateUserDto } from 'src/dtos/update-user.dto';
 import { UpdateMenuItemMetadataDto } from 'src/dtos/update-menu-item-metadata.dto';
 import { ApiProperty } from '@nestjs/swagger';
 
+export const ADMIN_ROLE_NAME = 'Admin';
+export const INTERNAL_ROLE_NAME = 'Internal User';
+export const PUBLIC_ROLE_NAME = 'Public';
+
 export class CreateRoleMetadataDto {
     @IsNotEmpty()
     @IsString()
@@ -54,84 +58,3 @@ export class CreateRoleMetadataDto {
     @ApiProperty()
     menuItemsCommand: string;
 }
-
-export const ADMIN_ROLE_NAME = 'Admin';
-
-export const INTERNAL_ROLE_NAME = 'Internal User';
-
-export const PUBLIC_ROLE_NAME = 'Public';
-
-export const INTERNAL_ROLE_PERMISSIONS = [
-    // User permissions
-    'UserController.findMany', //Why do we need this?
-    'UserController.checkIfPermissionExists',
-    'UserController.findOne',
-
-    // Menu permissions
-    'MenuItemMetadataController.findMany',
-    'MenuItemMetadataController.findUserMenus',
-    'MenuItemMetadataController.findOne',
-
-    // View metadata permissions
-    'ViewMetadataController.getLayout',
-    'ViewMetadataController.findMany',
-    'ViewMetadataController.findOne',
-
-    // Action metadata permissions
-    'ActionMetadataController.findMany',
-    'ActionMetadataController.findOne',
-
-    // User View metadata permissions
-    'UserViewMetadataController.upsert',
-    'UserViewMetadataController.findMany',
-    'UserViewMetadataController.findOne',
-
-    // IAM permissions
-    'AuthenticationController.changePassword',
-    'AuthenticationController.logout',
-    'AuthenticationController.me',
-
-    // Field Metadata permissions
-    'ModelMetadataController.navigation',
-
-    // Field Metadata permissions
-    'FieldMetadataController.getSelectionDynamicValues',
-    'FieldMetadataController.getSelectionDynamicValue',
-    'FieldMetadataController.findFieldDefaultMetaData',
-
-    // Saved Filters permissions
-    'SavedFiltersController.delete',
-    'SavedFiltersController.deleteMany',
-    'SavedFiltersController.findOne',
-    'SavedFiltersController.findMany',
-    'SavedFiltersController.recover',
-    'SavedFiltersController.recoverMany',
-    'SavedFiltersController.partialUpdate',
-    'SavedFiltersController.update',
-    'SavedFiltersController.insertMany',
-    'SavedFiltersController.create',
-
-    // Other permissions can be added here as required.
-    // Chatter permissions
-    'ChatterMessageController.create',
-    'ChatterMessageController.getChatterMessages',
-    'ChatterMessageController.postMessage',
-    'ChatterMessageController.findMany',
-
-    // Import
-    'ImportTransactionController.getImportTemplate',
-    'ImportTransactionController.getImportInstructions',
-    'ImportTransactionController.getImportMappingInfo',
-    'ImportTransactionController.startImportSync',
-    'ImportTransactionController.startImportAsync',
-    'ImportTransactionController.exportFailedImportedImports',
-
-    // Export permissions
-    'ExportTemplateController.startExportSync',
-    'ExportTemplateController.startExportAsync',
-
-    // List of values
-    'ListOfValuesController.findMany',
-    'ListOfValuesController.findOne',
-    // Media // [Not required], since media is always populated as part of a model
-]

package/src/dtos/create-scheduled-job.dto.ts

@@ -52,6 +52,10 @@ export class CreateScheduledJobDto {
     @ApiProperty()
     job: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    cronExpression: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty()
     moduleId: number;

package/src/dtos/create-setting.dto.ts

@@ -16,11 +16,24 @@ export class CreateSettingDto {
     @ApiProperty()
     type: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    level: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty({ description: "This is the user id field" })
     userId: number;
     @IsString()
     @IsOptional()
-    @ApiProperty({ description: "This is the user id field" })
+    @ApiProperty({ description: "This is the user userkey field" })
     userUserKey: string;
+
+    @IsOptional()
+    @IsInt()
+    @ApiProperty({ description: "This is the moduleMetadata id field" })
+    moduleMetadataId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty({ description: "This is the moduleMetadata userkey field" })
+    moduleMetadataUserKey: string;
 }

package/src/dtos/update-scheduled-job.dto.ts

@@ -58,6 +58,10 @@ export class UpdateScheduledJobDto {
     @ApiProperty()
     job: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    cronExpression: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty()
     moduleId: number;

package/src/dtos/update-setting.dto.ts

@@ -18,6 +18,10 @@ export class UpdateSettingDto {
     @ApiProperty()
     type: string;
     @IsOptional()
+    @IsString()
+    @ApiProperty()
+    level: string;
+    @IsOptional()
     @IsInt()
     @ApiProperty({ description: "This is the user id field" })
     userId: number;
@@ -25,4 +29,14 @@ export class UpdateSettingDto {
     @IsOptional()
     @ApiProperty({ description: "This is the user id field" })
     userUserKey: string;
+
+    @IsOptional()
+    @IsInt()
+    @ApiProperty({ description: "This is the moduleMetadata id field" })
+    moduleMetadataId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty({ description: "This is the moduleMetadata userkey field" })
+    moduleMetadataUserKey: string;
+
 }

package/src/entities/scheduled-job.entity.ts

@@ -29,6 +29,8 @@ export class ScheduledJob extends CommonEntity {
     dayOfWeek: string;
     @Column({ type: "varchar" })
     job: string;
+    @Column({ type: "varchar", nullable: true })
+    cronExpression: string;
     @Index()
     @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn({ referencedColumnName: 'id' })

package/src/entities/setting.entity.ts

@@ -1,17 +1,31 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { User } from 'src/entities/user.entity'
+import { ModuleMetadata } from './module-metadata.entity';
 
 @Entity("ss_setting")
 export class Setting extends CommonEntity {
+
     @Index({ unique: true })
     @Column({ type: "varchar", nullable: false })
     key: string;
+
     @Column({ type: "varchar", nullable: true })
     value: string;
+
     @Column({ name: "type", type: "varchar", nullable: true })
     type: string;
+
+    @Column({ name: "level", type: "varchar", nullable: true })
+    level: string;
+
+    @Index()
     @ManyToOne(() => User, { nullable: true })
     @JoinColumn()
     user: User;
-}
+
+    @Index()
+    @ManyToOne(() => ModuleMetadata, { nullable: true })
+    @JoinColumn()
+    moduleMetadata: ModuleMetadata;
+}

package/src/factories/mail.factory.ts

@@ -1,9 +1,10 @@
 import { Inject, Injectable, Logger } from "@nestjs/common";
 import { ConfigType } from "@nestjs/config";
 import { ModuleRef } from "@nestjs/core";
-import commonConfig from "src/config/common.config";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IMail } from "src/interfaces";
+import { SettingService } from "src/services/setting.service";
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 function norm(s?: string) {
     return s?.trim().toLowerCase();
@@ -16,12 +17,11 @@ export class MailFactory {
     constructor(
         private readonly moduleRef: ModuleRef, // Use the module ref to dynamically resolve the mail service
         private readonly solidRegistry: SolidRegistry,
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly settingService: SettingService,
     ) { }
 
     getMailService(): IMail {
-        const mailServiceName = this.commonConfiguration.emailProvider;
+        const mailServiceName = this.settingService.getConfigValue<SolidCoreSetting>("emailProvider") ?? "SMTPEMailService";
         const mailProviders = this.solidRegistry.getMailProviders();
         // Return the instance which matches the mailServiceName
         if (!mailProviders.length) {

package/src/factories/sms.factory.ts

@@ -1,9 +1,9 @@
-import { Inject, Injectable, Logger } from "@nestjs/common";
-import { ConfigType } from "@nestjs/config";
+import { Injectable, Logger } from "@nestjs/common";
 import { ModuleRef } from "@nestjs/core";
-import commonConfig from "src/config/common.config";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { ISMS } from "src/interfaces";
+import { SettingService } from "src/services/setting.service";
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 function norm(s?: string) {
     return s?.trim().toLowerCase();
@@ -17,13 +17,15 @@ export class SmsFactory {
     constructor(
         private readonly moduleRef: ModuleRef,
         private readonly solidRegistry: SolidRegistry,
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly settingService: SettingService,
+        // @Inject(commonConfig.KEY)
+        // private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     ) { }
 
     getSmsService(name: string = null): ISMS {
         // This is the default provider
-        const smsServiceName = name || this.commonConfiguration.smsProvider;
+        // const smsServiceName = name || this.commonConfiguration.smsProvider;
+        const smsServiceName = this.settingService.getConfigValue<SolidCoreSetting>('smsProvider');
         if (!smsServiceName) {
             throw new Error("Unable to resolve sms provider")
         }
@@ -40,4 +42,4 @@ export class SmsFactory {
         return smsServiceProvider.instance as ISMS;
     }
 
-}
+}

package/src/factories/whatsapp.factory.ts

@@ -1,9 +1,10 @@
 import { Inject, Injectable, Logger } from "@nestjs/common";
 import { ConfigType } from "@nestjs/config";
 import { ModuleRef } from "@nestjs/core";
-import commonConfig from "src/config/common.config";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IWhatsAppTransport } from "src/interfaces";
+import { SettingService } from "src/services/setting.service";
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 function norm(s?: string) {
     return s?.trim().toLowerCase();
@@ -16,13 +17,12 @@ export class WhatsAppFactory {
     constructor(
         private readonly moduleRef: ModuleRef, // Use the module ref to dynamically resolve the mail service
         private readonly solidRegistry: SolidRegistry,
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly settingService: SettingService,
     ) { }
 
     getWhatsappService(name: string = null): IWhatsAppTransport {
         // This is the default provider
-        const whatsappServiceName = name || this.commonConfiguration.whatsappProvider;
+        const whatsappServiceName = name || this.settingService.getConfigValue<SolidCoreSetting>("whatsappProvider");
         if (!whatsappServiceName) {
             throw new Error("Unable to resolve whatsapp provider")
         }

package/src/guards/access-token.guard.ts

@@ -1,3 +1,4 @@
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 import {
   CanActivate,
   ExecutionContext,
@@ -5,22 +6,20 @@ import {
   Injectable,
   UnauthorizedException,
 } from '@nestjs/common';
-import { ConfigType } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { Request } from 'express';
 import { ActiveUserData } from '../interfaces/active-user-data.interface';
-import { jwtConfig } from 'src/config/jwt.config';
 import { REQUEST_USER_KEY } from "../constants";
 import { PermissionMetadataService } from '../services/permission-metadata.service';
 import { ClsService } from 'nestjs-cls';
+import { SettingService } from '../services/setting.service';
 
 @Injectable()
 export class AccessTokenGuard implements CanActivate {
   constructor(
     private readonly jwtService: JwtService,
-    @Inject(jwtConfig.KEY)
-    private readonly jwtConfiguration: ConfigType<typeof jwtConfig>,
     private readonly permissionsService: PermissionMetadataService,
+    private readonly settingService: SettingService,
     private readonly cls: ClsService
   ) { }
 
@@ -32,9 +31,17 @@ export class AccessTokenGuard implements CanActivate {
       throw new UnauthorizedException();
     }
     try {
+
+      const jwtConfiguration = {
+        secret: this.settingService.getConfigValue<SolidCoreSetting>("secret"),
+        audience: this.settingService.getConfigValue<SolidCoreSetting>("audience"),
+        issuer: this.settingService.getConfigValue<SolidCoreSetting>("issuer"),
+        accessTokenTtl: this.settingService.getConfigValue<SolidCoreSetting>("accessTokenTtl"),
+        refreshTokenTtl: this.settingService.getConfigValue<SolidCoreSetting>("refreshTokenTtl")
+      }
       const payload: ActiveUserData = await this.jwtService.verifyAsync(
         token,
-        this.jwtConfiguration,
+        jwtConfiguration
       );
 
       // Load permissions given the user. 

package/src/helpers/command.service.ts

@@ -1,22 +1,54 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { exec } from 'child_process';
+import { spawn } from 'child_process';
+
+export type CommandWithArgs = {
+  command: string;
+  args: string[];
+};
 
 @Injectable()
 export class CommandService {
   private readonly logger = new Logger(CommandService.name);
 
-  async executeCommand(command: string): Promise<string> {
-    this.logger.debug(`Executing command :${command}`);
+  /**
+   * Execute a command with arguments array (cross-platform compatible)
+   */
+  async executeCommandWithArgs(commandWithArgs: CommandWithArgs): Promise<string> {
+    const { command, args } = commandWithArgs;
+    this.logger.debug(`Executing command: ${command} ${args.join(' ')}`);
+
     return new Promise<string>((resolve, reject) => {
-      exec(command, (error, stdout, stderr) => {
-        if (error) {
-          this.logger.error(`Error executing command :${command}`, error);
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          this.logger.error(`Error executing command :${command}`, stderr);
-          reject(stderr);
+      const isWindows = process.platform === 'win32';
+
+      // On Windows, we need to use cmd /c for commands that might be .cmd files (like npm scripts)
+      const spawnCommand = isWindows ? command : command;
+      const spawnArgs = args;
+
+      const child = spawn(spawnCommand, spawnArgs, {
+        shell: isWindows, // Use shell on Windows to handle .cmd files
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('error', (error) => {
+        this.logger.error(`Error executing command: ${command}`, error);
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        if (code !== 0) {
+          this.logger.error(`Command failed with code ${code}: ${command}`, stderr);
+          reject(new Error(stderr || `Command failed with exit code ${code}`));
           return;
         }
         resolve(stdout);

package/src/helpers/cors.helper.ts

@@ -1,9 +1,9 @@
 import { CorsOptions } from 'cors';
-import { ConfigService } from '@nestjs/config';
 
 /** Build CorsOptions from env; supports wildcards like https://*.example.com */
-export function buildDefaultCorsOptions(configService: ConfigService): CorsOptions {
-  const rawOrigins = configService.get<string>('SECURITY_CORS_ORIGINS') ?? '*';
+export function buildDefaultCorsOptions(): CorsOptions {
+  const rawOrigins = process.env.SECURITY_CORS_ORIGINS ?? '*';
+
   const allowed = rawOrigins.split(',').map(s => s.trim()).filter(Boolean);
 
   const escapeRx = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

package/src/helpers/error-mapper.service.ts

@@ -68,7 +68,6 @@ export class ErrorMapperService {
         for (const p of providers) {
             try {
                 const rules = p.rules() ?? [];
-                // Optional: namespace collision check can be added here if desired
                 all.push(...rules);
             } catch (e) {
                 this.logger.warn(`ErrorCodeProvider.rules() failed for ${p.name?.()}: ${e}`);

package/src/helpers/field-crud-managers/ManyToOneRelationFieldCrudManager.ts

@@ -77,13 +77,13 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         if (isNotEmpty(fieldId)) {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ id: fieldId });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
+                throw new Error(`Field ${this.options.fieldName} resolution failed. Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
         else {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
+                throw new Error(`Field ${this.options.fieldName} resolution failed. Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
 

package/src/helpers/google-oauth.helper.ts

@@ -1,9 +1,13 @@
-import { ConfigType } from "@nestjs/config";
-import { iamConfig } from "src/config/iam.config";
 
-export function isGoogleOAuthConfigured(iamConfiguration: ConfigType<typeof iamConfig>): boolean {
-    const googleOauthConfig = iamConfiguration.googleOauth;
-    
-    return !!googleOauthConfig.clientID  
+export type GoogleAuthConfiguration = {
+  clientID: String,
+  clientSecret: String,
+  callbackURL: String,
+  redirectURL: String
+}
+
+export function isGoogleOAuthConfigured(googleOauthConfig: GoogleAuthConfiguration): boolean {
+
+  return !!googleOauthConfig.clientID
     && !!googleOauthConfig.clientSecret && !!googleOauthConfig.callbackURL && !!googleOauthConfig.redirectURL;
-  }
+}

package/src/helpers/module.helper.ts

@@ -32,7 +32,7 @@ export const getDynamicModuleNames = (): string[] => {
     .map(dirent => dirent.name);
 
   // logger.debug(`Enabled dynamic modules:`, enabledModules);
-  console.log(`Dynamic Modules Are:`, enabledModules);
+  // console.log(`Dynamic Modules Are:`, enabledModules);
 
   return enabledModules;
 }
@@ -67,7 +67,7 @@ export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
     .map(dirent => dirent.name);
 
   // logger.debug(`Enabled dynamic modules basis src:`, enabledModules);
-  console.log(`Src Based Dynamic Modules Are:`, enabledModules);
+  // console.log(`Src Based Dynamic Modules Are:`, enabledModules);
   return enabledModules;
 }
 

package/src/helpers/schematic.service.ts

@@ -1,7 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { snakeCase } from "lodash";
 import { FieldMetadata } from 'src/entities/field-metadata.entity';
-import { CommandService } from './command.service';
+import { CommandService, CommandWithArgs } from './command.service';
 import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
@@ -17,7 +17,7 @@ type ModelAndFieldGenerationOptions = {
   table?: string;
   dataSource: string;
   modelEnableSoftDelete?: boolean;
-  parentModel?: string; 
+  parentModel?: string;
   parentModule?: string;
   draftPublishWorkflowEnabled?: boolean;
   isLegacyTable?: boolean;
@@ -33,6 +33,8 @@ export const REFRESH_MODEL_COMMAND = 'refresh-model';
 export class SchematicService {
   private readonly logger = new Logger(SchematicService.name);
   private readonly SCHEMATIC_PROJECT = '@solidstarters/solid-code-builder';
+  private readonly SCHEMATICS_COMMAND = 'schematics';
+
   constructor(private readonly commandService: CommandService, private readonly solidRegistry: SolidRegistry) { }
 
   async executeSchematicCommand(
@@ -40,91 +42,95 @@ export class SchematicService {
     options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug = false,
   ): Promise<string> {
-    return await this.commandService.executeCommand(
-      this.generateSchematicCommand(command, options, debug),
-    );
+    const commandWithArgs = this.generateSchematicCommand(command, options, debug);
+    return await this.commandService.executeCommandWithArgs(commandWithArgs);
   }
 
   private generateSchematicCommand(
     command: string,
     options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug: boolean,
-  ): string {
-    const baseCommand = `schematics ${this.SCHEMATIC_PROJECT}:${command} --debug=${debug}`;
+  ): CommandWithArgs {
+    const schematicName = `${this.SCHEMATIC_PROJECT}:${command}`;
+    const baseArgs = [schematicName, `--debug=${debug}`];
+
     if (
       command === REMOVE_FIELDS_COMMAND ||
       command === REFRESH_MODEL_COMMAND
     ) {
-      const {fields, ...modelSpecificOptions} = options as ModelAndFieldGenerationOptions;
-      const modelCommand = this.buildModelGenerationCommand(baseCommand, modelSpecificOptions);
-      const fieldCommand = this.buildFieldGenerationCommand(fields);
-      const schematicCommand = modelCommand + ' ' + fieldCommand;
-      this.logger.debug('schematicCommand', schematicCommand);
-      return schematicCommand;
+      const { fields, ...modelSpecificOptions } = options as ModelAndFieldGenerationOptions;
+      const modelArgs = this.buildModelGenerationArgs(modelSpecificOptions);
+      const fieldArgs = this.buildFieldGenerationArgs(fields);
+      const args = [...baseArgs, ...modelArgs, ...fieldArgs];
+      this.logger.debug('schematicCommand args', args);
+      return { command: this.SCHEMATICS_COMMAND, args };
     } else if (command === ADD_MODULE_COMMAND) {
       const moduleOptions = options as GenerateModuleOptions;
-      const schematicCommand = ` ${baseCommand} --module=${moduleOptions.module}`;
-      this.logger.debug('schematicCommand', schematicCommand);
-      return schematicCommand;
+      const args = [...baseArgs, `--module=${moduleOptions.module}`];
+      this.logger.debug('schematicCommand args', args);
+      return { command: this.SCHEMATICS_COMMAND, args };
     } else {
       throw new Error('Schematic command not supported.');
     }
   }
 
-  private buildFieldGenerationCommand(fields: FieldMetadata[]) {
+  private buildFieldGenerationArgs(fields: FieldMetadata[]): string[] {
     return fields
       .filter((field) => {
         return !this.solidRegistry.getCommonEntityKeys().map(key => key.toString()).includes(field.name);
       })
       .map((field) => {
-        return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
-      })
-      .join(' ');
+        // Using argument array eliminates the need for shell-specific quoting
+        return `--fields=${JSON.stringify(field)}`;
+      });
   }
 
-  private buildModelGenerationCommand(baseCommand: string, modelSpecificOptions: ModelGenerationOptions): string {
-    let modelCommand = `${baseCommand} --module=${modelSpecificOptions.module} --model=${modelSpecificOptions.model}`;
+  private buildModelGenerationArgs(modelSpecificOptions: ModelGenerationOptions): string[] {
+    const args: string[] = [
+      `--module=${modelSpecificOptions.module}`,
+      `--model=${modelSpecificOptions.model}`,
+    ];
 
-    // Make below options code generate i.e if option exists then add to command with proper casing
     if (modelSpecificOptions.moduleDisplayName) {
-      modelCommand += ` --module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`;
+      args.push(`--module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`);
     }
 
     if (modelSpecificOptions.table) {
-      modelCommand += ` --table=${modelSpecificOptions.table}`;
+      args.push(`--table=${modelSpecificOptions.table}`);
     }
 
     if (modelSpecificOptions.dataSource) {
-      modelCommand += ` --data-source=${modelSpecificOptions.dataSource}`;
+      args.push(`--data-source=${modelSpecificOptions.dataSource}`);
     }
 
     if (modelSpecificOptions.modelEnableSoftDelete) {
-      modelCommand += ` --model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`;
+      args.push(`--model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`);
     }
 
     if (modelSpecificOptions.parentModel) {
-      modelCommand += ` --parent-model=${modelSpecificOptions.parentModel}`;
+      args.push(`--parent-model=${modelSpecificOptions.parentModel}`);
     }
+
     if (modelSpecificOptions.parentModule) {
-      modelCommand += ` --parent-module=${modelSpecificOptions.parentModule}`;
+      args.push(`--parent-module=${modelSpecificOptions.parentModule}`);
     }
 
     if (modelSpecificOptions.draftPublishWorkflowEnabled) {
-      modelCommand += ` --draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`;
+      args.push(`--draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`);
     }
 
     if (modelSpecificOptions.isLegacyTable) {
-      modelCommand += ` --is-legacy-table=${modelSpecificOptions.isLegacyTable}`;
+      args.push(`--is-legacy-table=${modelSpecificOptions.isLegacyTable}`);
     }
 
     if (modelSpecificOptions.isLegacyTableWithId) {
-      modelCommand += ` --is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`;
+      args.push(`--is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`);
     }
 
     if (modelSpecificOptions.dataSourceType) {
-      modelCommand += ` --data-source-type=${modelSpecificOptions.dataSourceType}`;
+      args.push(`--data-source-type=${modelSpecificOptions.dataSourceType}`);
     }
-    
-    return modelCommand;
+
+    return args;
   }
 }