@solidstarters/solid-core 1.2.23 → 1.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.23",
+  "version": "1.2.25",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,6 +53,7 @@
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0",
     "pg": "^8.11.3",
+    "mysql2": "^3.13.0",
     "pluralize": "^8.0.0",
     "puppeteer": "^23.2.0",
     "reflect-metadata": "^0.1.13",

package/src/controllers/user.controller.ts

@@ -36,6 +36,14 @@ export class UserController {
     return this.service.update(id, updateDto, files);
   }
 
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id/update-user-and-roles')
+  updateUser(@Param('id') id: number, @Body() updateDto: any, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.updateUser(id, updateDto, files);
+  }
+
+
   @ApiBearerAuth("jwt")
   @Patch(':id')
   @UseInterceptors(AnyFilesInterceptor())

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

@@ -301,7 +301,7 @@ export class CreateFieldMetadataDto {
   @ApiProperty({ description: 'Related model for the relation. Only for type=relation' })
   @IsString()
   @IsOptional()
-  relationModelSingularName: string;
+  relationCoModelSingularName: string;
 
   @ApiProperty({ description: 'Create inverse relation. Only for type=relation', })
   @IsBoolean()
@@ -319,7 +319,7 @@ export class CreateFieldMetadataDto {
 
   @ApiProperty({ description: 'Related field module. Only required for type=relation and relationType=many-to-many, i.e if the related many to many field belongs to a different model' })
   @IsOptional()
-  relationModelFieldName: string;
+  relationCoModelFieldName: string;
 
   @ApiProperty({description: 'Only for type=relation, many-to-many. This field is used to set the owner of the many-to-many relation'})
   @IsOptional()
@@ -386,20 +386,15 @@ export class CreateFieldMetadataDto {
   @IsOptional()
   columnName: string
 
-  @ApiProperty({ description: "Is User Key" })
-  @IsOptional()
-  @IsBoolean()
-  readonly isUserKey: boolean
-
-  @ApiProperty({ description: 'Relation Join Column Name of Field', })
+  @ApiProperty({ description: 'Relation CoModel Column Name of Field', })
   @IsString()
   @IsOptional()
-  relationJoinColumnName: string
+  relationCoModelColumnName: string
 
-  @ApiProperty({ description: 'Join Column Name of Field', })
-  @IsString()
+  @ApiProperty({ description: "Is User Key" })
   @IsOptional()
-  joinColumnName: string
+  @IsBoolean()
+  readonly isUserKey: boolean
 
   @ApiProperty({ description: 'Relation Join Table Name of Field', })
   @IsString()

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

@@ -7,17 +7,29 @@ export class CreateMediaDto {
 
     @IsNotEmpty()
     @IsInt()
-    modelMetadataId: number; 
+    modelMetadataId: number;
 
     @IsNotEmpty()
     @IsString()
     relativeUri: string;
-    
+
+    @IsOptional()
+    @IsString()
+    mimeType: string;
+
+    @IsOptional()
+    @IsInt()
+    fileSize: number;
+
+    @IsOptional()
+    @IsString()
+    originalFileName: string;
+
     @IsNotEmpty()
     @IsInt()
     mediaStorageProviderMetadataId: number;
 
     @IsNotEmpty()
     @IsInt()
-    fieldMetadataId: number; 
+    fieldMetadataId: number;
 }

package/src/entities/field-metadata.entity.ts

@@ -67,7 +67,7 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: "private", default: false })
     private: boolean;
 
-    @Column("text", { array: true, name: 'media_types', nullable: true })
+    @Column("json", { name: 'media_types', nullable: true })
     mediaTypes: string[];
 
     @Column({ name: 'media_max_size_kb', nullable: true })
@@ -84,7 +84,7 @@ export class FieldMetadata extends CommonEntity {
     relationType: string;
 
     @Column({ name: 'relation_model_singular_name', nullable: true })
-    relationModelSingularName: string;
+    relationCoModelSingularName: string;
 
     @Column({ name: "relation_create_inverse", default: false })
     relationCreateInverse: boolean;
@@ -97,7 +97,7 @@ export class FieldMetadata extends CommonEntity {
 
     // This field will be used to set the inverse field name in the related model e.g required for many to many relation
     @Column({ name: 'relation_model_field_name', nullable: true })
-    relationModelFieldName: string;
+    relationCoModelFieldName: string;
 
     @Column({ name: 'is_relation_many_to_many_owner', nullable: true })
     isRelationManyToManyOwner: boolean;
@@ -111,7 +111,7 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'selection_static_values', nullable: true, type: 'simple-array' })
     selectionStaticValues: string[];
 
-    @Column({ name: 'selection_value_type', nullable: true, type: 'text', default: 'string' })
+    @Column({ name: 'selection_value_type', nullable: true, type: 'text' }) // text type cannot have a default value
     selectionValueType: string = 'string';
 
     // @Column({ name: "computed", default: false })
@@ -138,14 +138,11 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'column_name', nullable: true })
     columnName: string;
 
-    @Column({ name: "isUserKey", default: false })
-    isUserKey: boolean;
-
-    @Column({ name: 'relation_join_column_name', nullable: true })
-    relationJoinColumnName: string;
+    @Column({ name: 'relation_co_model_column_name', nullable: true })
+    relationCoModelColumnName: string;
 
-    @Column({ name: 'join_column_name', nullable: true })
-    joinColumnName: string;
+    @Column({ name: "is_user_key", default: false })
+    isUserKey: boolean;
 
     @Column({ name: 'relation_join_table_name', nullable: true })
     relationJoinTableName: string;

package/src/entities/media-storage-provider-metadata.entity.ts

@@ -4,7 +4,7 @@ import { Column, Entity, Index } from "typeorm";
 @Entity("ss_media_storage_provider_metadata")
 export class MediaStorageProviderMetadata extends CommonEntity {
     @Index({ unique: true })
-    @Column({ unique: true })
+    @Column({ })
     name: string;
 
     @Column()

package/src/entities/media.entity.ts

@@ -19,6 +19,15 @@ export class Media extends CommonEntity {
     @Column({ name: "relative_uri" })
     relativeUri: string;
 
+    @Column({ name: "mime_type" })
+    mimeType: string;
+
+    @Column({ name: "file_size" })
+    fileSize: number;
+
+    @Column({ name: "original_file_name" })
+    originalFileName: string;
+
     @Index()
     @ManyToOne(() => MediaStorageProviderMetadata)
     @JoinColumn({ name: "media_storage_provider_metadata_id" })

package/src/entities/mysql-issues

@@ -0,0 +1,14 @@
+# Issues
+1. @Column("text", { array: true, name: 'media_types', nullable: true }) // array type not supported. No impact on code generation. not being used
+2. 
+default values not allowed for text,blog // Code generation impact. If we want to support default values for long text/rich text, then changes to be made.
+date value is not supported propertly in mysql
+i.e new Date("2025-02-11T00:00:00.000Z")
+3. Below type of code cannot exist. // No impact on code generation. Not being used.
+@Index({ unique: true })
+@Column({ unique: true })
+4.  // Impact on code generation. unique index to be generated by using @Index and not @Column.
+@Index({ unique: true })
+@Column({ })
+5. i.e new Date("2025-02-11T00:00:00.000Z")
+-> Remove the column default value

package/src/entities/permission-metadata.entity.ts

@@ -4,8 +4,8 @@ import { RoleMetadata } from 'src/entities/role-metadata.entity'
 @Entity("ss_permission_metadata")
 export class PermissionMetadata extends CommonEntity {
 
-    @Index()
-    @Column({ name: "name", type: "varchar", unique: true })
+    @Index({unique: true})
+    @Column({ name: "name", type: "varchar" })
     name: string;
 
     @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.permissions, { cascade: ['insert', 'update'] })

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

@@ -8,12 +8,12 @@ import { EntityManager, In } from "typeorm";
 export interface ManyToManyRelationFieldOptions {
     // Add options for relation field
     required: boolean | undefined | null;
-    relationModelSingularName: string | undefined | null;
+    relationCoModelSingularName: string | undefined | null;
     modelSingularName: string | undefined | null;
     isInverseSide: boolean;
     entityManager: EntityManager;
     fieldName: string;
-    relationModelFieldName?: string;
+    relationCoModelFieldName?: string;
 }
 
 const linkCommands = [RelationFieldsCommand.link, RelationFieldsCommand.unlink, RelationFieldsCommand.set];
@@ -33,9 +33,9 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
             this.commandFieldName = `${this.options.fieldName}Command`;
         }
         else {
-            this.valueFieldName = `${this.options.relationModelFieldName}`;
-            this.idFieldName = `${this.options.relationModelFieldName}Ids`;
-            this.commandFieldName = `${this.options.relationModelFieldName}Command`;
+            this.valueFieldName = `${this.options.relationCoModelFieldName}`;
+            this.idFieldName = `${this.options.relationCoModelFieldName}Ids`;
+            this.commandFieldName = `${this.options.relationCoModelFieldName}Command`;
         }
     }
 
@@ -71,7 +71,7 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
         const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
         const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationModelSingularName));
+        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
         const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);

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

@@ -7,7 +7,7 @@ import { EntityManager } from "typeorm";
 export interface ManyToOneRelationFieldOptions {
     // Add options for relation field
     required: boolean | undefined | null;
-    relationModelSingularName: string | undefined | null;
+    relationCoModelSingularName: string | undefined | null;
     fieldName: string | undefined | null;
     modelUserKeyFieldName: string | undefined | null;
     modelSingularName: string | undefined | null;
@@ -64,17 +64,17 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         if ((isEmpty(fieldId)) && isEmpty(fieldUserKeyValue)) return dto;
 
         // // Load the related entity from the database, using the repository of the related entity
-        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationModelSingularName));
+        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
         if (isNotEmpty(fieldId)) {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).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.relationModelSingularName}`);
+                throw new Error(`ManyToOneRelationFieldCrudManager: Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
         else {
             dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.modelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.modelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationModelSingularName}`);
+                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.modelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
 

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

@@ -8,8 +8,8 @@ import { EntityManager, In } from "typeorm";
 export interface OneToManyRelationFieldOptions {
     // Add options for relation field
     required: boolean | undefined | null;
-    relationModelSingularName: string | undefined | null;
-    inverseRelationModelFieldName: string | undefined | null;
+    relationCoModelSingularName: string | undefined | null;
+    inverseRelationCoModelFieldName: string | undefined | null;
     modelSingularName: string | undefined | null;
     inverseFieldName: string | undefined | null;
     entityManager: EntityManager | undefined | null;
@@ -25,9 +25,9 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
     private readonly commandFieldName: string;
 
     constructor(private readonly options: OneToManyRelationFieldOptions) {
-        this.valueFieldName = this.options.inverseRelationModelFieldName ?? `${this.options.relationModelSingularName}s`;
-        this.idFieldName = `${this.options.inverseRelationModelFieldName ?? this.options.relationModelSingularName}Ids`;
-        this.commandFieldName = `${this.options.inverseRelationModelFieldName ?? this.options.relationModelSingularName}Command`;
+        this.valueFieldName = this.options.inverseRelationCoModelFieldName ?? `${this.options.relationCoModelSingularName}s`;
+        this.idFieldName = `${this.options.inverseRelationCoModelFieldName ?? this.options.relationCoModelSingularName}Ids`;
+        this.commandFieldName = `${this.options.inverseRelationCoModelFieldName ?? this.options.relationCoModelSingularName}Command`;
     }
 
     validate(dto: any) {
@@ -78,7 +78,7 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
         const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
         const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationModelSingularName));
+        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
         const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);

package/src/helpers/schematic.service.ts

@@ -13,6 +13,7 @@ type FieldOptions = {
   table?: string;
   dataSource: string;
   fields: any[]; //FIXME This type can be improved
+  modelEnableSoftDelete?: boolean;
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
@@ -52,7 +53,6 @@ export class SchematicService {
       command === REFRESH_MODEL_COMMAND
     ) {
       const fieldOptions = options as FieldOptions;
-      // console.log('fieldOptions', fieldOptions);
       let modelCommand = `${baseCommand} --module=${fieldOptions.module} --model=${fieldOptions.model}`;
       if (fieldOptions.moduleDisplayName) {
         modelCommand += ` --module-display-name=${snakeCase(fieldOptions.moduleDisplayName)}`;
@@ -65,6 +65,10 @@ export class SchematicService {
       if (fieldOptions.dataSource) {
         modelCommand += ` --data-source=${fieldOptions.dataSource}`;
       }
+
+      if (fieldOptions.modelEnableSoftDelete) {
+        modelCommand += ` --model-enable-soft-delete=${fieldOptions.modelEnableSoftDelete}`;
+      }
       
       let fieldCommand = fieldOptions.fields
         .filter((field) => {

package/src/seeders/module-metadata-seeder.service.ts

@@ -205,7 +205,19 @@ export class ModuleMetadataSeederService {
         this.logger.debug(`About to add all permissions to the Admin role`);
         await this.roleService.addAllPermissionsToRole("Admin");
         // 2. Give wrapSettings permissions to the Public role.
-        await this.roleService.addPermissionToRole('Public', 'SettingController.wrapSettings');
+        const internalRolePermission = ['UserController.findMany',
+            'UserController.checkIfPermissionExists',
+            'UserController.findOne',
+            'MenuItemMetadataController.findMany',
+            'MenuItemMetadataController.findUserMenus',
+            'MenuItemMetadataController.findOne',
+            'ViewMetadataController.getLayout',
+            'ViewMetadataController.findMany',
+            'ViewMetadataController.findOne',
+            'AuthenticationController.changePassword'
+        ]
+        await this.roleService.addPermissionToRole('Internal User', internalRolePermission);
+        await this.roleService.addPermissionToRole('Public', ['SettingController.wrapSettings']);
         this.logger.log(`All Seeders finished`);
         this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);
     }
@@ -354,9 +366,9 @@ export class ModuleMetadataSeederService {
         for (let j = 0; j < actions.length; j++) {
             const actionData = actions[j];
             actionData['module'] = await this.moduleMetadataService.findOneByUserKey(actionData.moduleUserKey);
+            actionData['model'] = await this.modelMetadataService.findOneByUserKey(actionData.modelUserKey);
             if (actionData.type === 'solid') {
                 actionData['view'] = await this.solidViewService.findOneByUserKey(actionData.viewUserKey);
-                actionData['model'] = await this.modelMetadataService.findOneByUserKey(actionData.modelUserKey);
             }
             await this.solidActionService.upsert(actionData);
         }
@@ -378,7 +390,7 @@ export class ModuleMetadataSeederService {
             viewData['model'] = await this.modelMetadataService.findOneByUserKey(viewData.modelUserKey);
             // await this.solidViewService.upsert(viewData);
             // First check if module already exists using name
-             await this.solidViewService.createIfNotPresent(viewData);
+            await this.solidViewService.createIfNotPresent(viewData);
 
         }
     }