@solidstarters/solid-core 1.2.24 → 1.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.24",
+  "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",

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

@@ -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;
@@ -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.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/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);
 
         }
     }