@solidxai/core 0.1.4 → 0.1.5-beta.1

package/src/dtos/update-security-rule.dto.ts

@@ -5,32 +5,39 @@ export class UpdateSecurityRuleDto {
     @IsOptional()
     @IsInt()
     id: number;
+
     @IsNotEmpty()
     @IsOptional()
     @IsString()
     @ApiProperty()
     name: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsString()
     @ApiProperty()
     description: string;
+
     @IsOptional()
     @IsInt()
     @ApiProperty()
     roleId: number;
+
     @IsString()
     @IsOptional()
     @ApiProperty()
     roleUserKey: string;
+
     @IsOptional()
     @IsInt()
     @ApiProperty()
     modelMetadataId: number;
+
     @IsString()
     @IsOptional()
     @ApiProperty()
     modelMetadataUserKey: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsJSON()

package/src/dtos/update-sms-template.dto.ts

@@ -3,42 +3,42 @@ import { CreateSmsTemplateDto } from './create-sms-template.dto';
 import { IsString } from 'class-validator';
 import { IsOptional, Matches, IsNotEmpty, IsBoolean } from 'class-validator';
 
-export class UpdateSmsTemplateDto extends PartialType(CreateSmsTemplateDto) { 
-@IsOptional()
-@IsString()
-@ApiProperty()
-type: string;
+export class UpdateSmsTemplateDto extends PartialType(CreateSmsTemplateDto) {
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    type: string;
 
-@IsNotEmpty()
-@IsOptional()
-@Matches(/[a-z]+(-[a-z]+)*/)
-@IsString()
-@ApiProperty()
-name: string;
+    @IsNotEmpty()
+    @IsOptional()
+    @Matches(/[a-z]+(-[a-z]+)*/)
+    @IsString()
+    @ApiProperty()
+    name: string;
 
-@IsOptional()
-@IsString()
-@ApiProperty()
-smsProviderTemplateId: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    smsProviderTemplateId: string;
 
-@IsNotEmpty()
-@IsOptional()
-@IsString()
-@ApiProperty()
-displayName: string;
+    @IsNotEmpty()
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    displayName: string;
 
-@IsOptional()
-@IsString()
-@ApiProperty()
-body: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    body: string;
 
-@IsOptional()
-@IsString()
-@ApiProperty()
-description: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    description: string;
 
-@IsOptional()
-@IsBoolean()
-@ApiProperty()
-active: boolean;
+    @IsOptional()
+    @IsBoolean()
+    @ApiProperty()
+    active: boolean;
 } { }

package/src/dtos/update-view-metadata.dto.ts

@@ -7,58 +7,70 @@ export class UpdateViewMetadataDto {
     @IsOptional()
     @IsInt()
     id: number;
+
     @IsNotEmpty()
     @IsOptional()
     @Matches(/[a-z]+(-[a-z]+)*/)
     @IsString()
     @ApiProperty()
     name: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsString()
     @ApiProperty()
     displayName: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsString()
     @ApiProperty()
     type: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsJSON()
     @ApiProperty()
     context: any;
+
     @IsNotEmpty()
     @IsOptional()
     @IsJSON()
     @ApiProperty()
     layout: any;
+
     @IsOptional()
     @IsInt()
     @ApiProperty()
     moduleId: number;
+
     @IsString()
     @IsOptional()
     @ApiProperty()
     moduleUserKey: string;
+
     @IsOptional()
     @IsInt()
     @ApiProperty()
     modelId: number;
+
     @IsString()
     @IsOptional()
     @ApiProperty()
     modelUserKey: string;
+
     @IsOptional()
     @ApiProperty()
     @IsArray()
     @ValidateNested({ each: true })
     @Type(() => UpdateUserViewMetadataDto)
     userViewMetadata: UpdateUserViewMetadataDto[];
+
     @IsOptional()
     @IsArray()
     @ApiProperty()
     userViewMetadataIds: number[];
+
     @IsString()
     @IsOptional()
     @ApiProperty()

package/src/entities/chatter-message-details.entity.ts

@@ -3,6 +3,7 @@ import { Entity, JoinColumn, ManyToOne, Column, Index } from 'typeorm';
 import { ChatterMessage } from 'src/entities/chatter-message.entity'
 @Entity("ss_chatter_message_details")
 export class ChatterMessageDetails extends CommonEntity {
+    @Index()
     @ManyToOne(() => ChatterMessage, { nullable: true })
     @JoinColumn()
     chatterMessage: ChatterMessage;

package/src/entities/chatter-message.entity.ts

@@ -3,6 +3,7 @@ import { Entity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm
 import { User } from 'src/entities/user.entity'
 import { ChatterMessageDetails } from './chatter-message-details.entity';
 
+@Index(["coModelName", "coModelEntityId"])
 @Entity("ss_chatter_message")
 export class ChatterMessage extends CommonEntity {
     @Index()

package/src/entities/common.entity.ts

@@ -1,6 +1,6 @@
 import { Column, CreateDateColumn, DeleteDateColumn, Index, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
 import { Exclude, Expose } from "class-transformer";
-import { LocalDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
+import { UtcDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
 
 @Exclude()
 export abstract class CommonEntity {
@@ -8,13 +8,13 @@ export abstract class CommonEntity {
     @PrimaryGeneratedColumn({ type: 'integer' })
     id: number
 
-    @CreateDateColumn({ name: "created_at", transformer: LocalDateTimeTransformer })
+    @CreateDateColumn({ name: "created_at", transformer: UtcDateTimeTransformer })
     createdAt: Date;
 
-    @UpdateDateColumn({ name: "updated_at", transformer: LocalDateTimeTransformer })
+    @UpdateDateColumn({ name: "updated_at", transformer: UtcDateTimeTransformer })
     updatedAt: Date;
 
-    @DeleteDateColumn({ name: "deleted_at", transformer: LocalDateTimeTransformer })
+    @DeleteDateColumn({ name: "deleted_at", transformer: UtcDateTimeTransformer })
     @Index()
     deletedAt: Date;
 
@@ -22,7 +22,7 @@ export abstract class CommonEntity {
     deletedTracker: string;
 
     @Expose()
-    @Column({ name: 'published_at', default: null, nullable: true, transformer: LocalDateTimeTransformer })
+    @Column({ name: 'published_at', default: null, nullable: true, transformer: UtcDateTimeTransformer })
     publishedAt: Date;
 
     @Expose()

package/src/entities/legacy-common.entity.ts

@@ -1,7 +1,7 @@
 import { Exclude, Expose, Type } from "class-transformer";
 import { Column, CreateDateColumn, DeleteDateColumn, Index, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
 import type { User } from "./user.entity";
-import { LocalDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
+import { UtcDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
 
 export const LEGACY_TABLE_FIELDS_PREFIX = 'ss';
 
@@ -12,13 +12,13 @@ export abstract class LegacyCommonEntity {
     // @Generated("increment")
     // id: number
 
-    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: LocalDateTimeTransformer })
+    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: UtcDateTimeTransformer })
     createdAt: Date;
 
-    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: LocalDateTimeTransformer })
+    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: UtcDateTimeTransformer })
     updatedAt: Date;
 
-    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: LocalDateTimeTransformer })
+    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: UtcDateTimeTransformer })
     @Index()
     deletedAt: Date;
 
@@ -26,7 +26,7 @@ export abstract class LegacyCommonEntity {
     deletedTracker: string;
 
     @Expose()
-    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null, nullable: true, transformer: LocalDateTimeTransformer })
+    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null, nullable: true, transformer: UtcDateTimeTransformer })
     publishedAt: Date;
 
     @Expose()

package/src/entities/saved-filters.entity.ts

@@ -30,4 +30,7 @@ export class SavedFilters extends CommonEntity {
 
     @Column({ name: "description", type: "text", nullable: true })
     description: string;
+
+    @Column({ nullable: true, default: false })
+    isSeeded: boolean = false;
 }

package/src/entities/user.entity.ts

@@ -10,7 +10,7 @@ import { Exclude, Expose } from "class-transformer";
 export class User extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     @Expose()
-    fullName: string; 
+    fullName: string;
     @Index({ unique: true })
     @Column({ type: "varchar" })
     @Expose()
@@ -111,6 +111,9 @@ export class User extends CommonEntity {
     // dont send to client
     @Column({ nullable: true })
     rehashedAt: Date;
+    // dont send to client
+    @Column({ type: "int", default: 0 })
+    failedLoginAttempts: number = 0;
     @Expose()
     _media: any;
 }

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

@@ -14,6 +14,8 @@ export interface ManyToManyRelationFieldOptions {
     entityManager: EntityManager;
     fieldName: string;
     relationCoModelFieldName?: string;
+    isUpdate?: boolean;
+    entityId?: number;
 }
 
 const linkCommands = [RelationFieldsCommand.link, RelationFieldsCommand.unlink, RelationFieldsCommand.set];
@@ -74,16 +76,21 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
         const relatedEntityName = classify(this.options.relationCoModelSingularName);
         const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName)
 
-        dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
+        const result = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
+        if (result !== undefined) {
+            dto[this.valueFieldName] = result;
+        } else {
+            delete dto[this.valueFieldName];
+        }
         return dto;
     }
 
-    private async transformByCommand(dto: any, relatedEntityRepository: any, currentEntityRepository: any): Promise<any[]> {
+    private async transformByCommand(dto: any, relatedEntityRepository: any, currentEntityRepository: any): Promise<any[] | undefined> {
         // TODO : Need to add support for the multiple commands
         const command = dto[this.commandFieldName];
         const values = dto[this.valueFieldName];
         const ids = dto[this.idFieldName];
-        
+
         switch (command) {
             case RelationFieldsCommand.create:
                 return await this.transformForCommandCreate(values, relatedEntityRepository);
@@ -94,15 +101,15 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
             case RelationFieldsCommand.clear:
                 return this.transformForCommandClear();
             case RelationFieldsCommand.set:
-                return await this.transformForCommandSet(ids, relatedEntityRepository, dto, currentEntityRepository);    
+                return await this.transformForCommandSet(ids, relatedEntityRepository);
             case RelationFieldsCommand.link:
-                return await this.tranformForCommandLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+                return await this.tranformForCommandLink(ids, relatedEntityRepository);
             case RelationFieldsCommand.unlink:
-                return await this.transformForCommandUnLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+                return await this.transformForCommandUnLink(ids);
             default:
                 this.logger.log(`Invalid command ${command}`);
                 return null;
-                
+
         }
     }
 
@@ -110,46 +117,50 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
         return []
     }
 
-    private async transformForCommandSet(ids: any[], relatedEntityRepository: any,  dto: any, currentEntityRepository: any): Promise<any[]> {
-        // Load the entities with the ids passed
+    private async transformForCommandSet(ids: any[], relatedEntityRepository: any): Promise<any[]> {
         const loadedEntities: any[] = await relatedEntityRepository.find({
-            where : {id: In(ids) } 
+            where : {id: In(ids) }
         })
         if (loadedEntities.length !== ids.length) {
-            throw new Error('Invalid entity ids provided for linking');
+            throw new Error('Invalid entity ids provided for set');
         }
 
         return loadedEntities;
     }
 
-    private async tranformForCommandLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
-        const tranformedRelatedFields = [];
-        // Load the entities with the ids passed
-        const loadedEntities: any[] = await relatedEntityRepository.find({
-            where : {id: In(ids) } 
-        })
-        if (loadedEntities.length !== ids.length) {
+    private async tranformForCommandLink(ids: any[], relatedEntityRepository: any): Promise<undefined> {
+        if (!this.options.isUpdate) {
+            throw new Error('Link command is only supported for update operations');
+        }
+
+        const count: number = await relatedEntityRepository.count({
+            where: { id: In(ids) }
+        });
+        if (count !== ids.length) {
             throw new Error('Invalid entity ids provided for linking');
         }
-        tranformedRelatedFields.push(...loadedEntities);
 
-        return tranformedRelatedFields;
+        await this.options.entityManager
+            .createQueryBuilder()
+            .relation(classify(this.options.modelSingularName), this.valueFieldName)
+            .of(this.options.entityId)
+            .add(ids);
+
+        return undefined;
     }
 
-    private async transformForCommandUnLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
-        if (dto.id == null) {
-            throw new Error('Entity id is required for unlinking');
-        } 
+    private async transformForCommandUnLink(ids: any[]): Promise<undefined> {
+        if (!this.options.isUpdate) {
+            throw new Error('Unlink command is only supported for update operations');
+        }
 
-        const tranformedRelatedFields = [];
-        const entityInstance = await currentEntityRepository.findOne({
-            where: {id: dto.id},
-            relations: [this.valueFieldName]
-        });
-        const filteredEntities = entityInstance[this.valueFieldName].filter((entity) => !ids.includes(entity.id));
-        tranformedRelatedFields.push(...filteredEntities);
+        await this.options.entityManager
+            .createQueryBuilder()
+            .relation(classify(this.options.modelSingularName), this.valueFieldName)
+            .of(this.options.entityId)
+            .remove(ids);
 
-        return tranformedRelatedFields;
+        return undefined;
     }
 
     private async transformForCommandCreate(values: any[], relatedEntityRepository: any): Promise<any[]> {

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

@@ -1,7 +1,7 @@
 import { classify } from "@angular-devkit/core/src/utils/strings";
+import { Logger } from "@nestjs/common";
 import { isEmpty, isEnum, isInt, isNotEmpty } from "class-validator";
 import { RelationFieldsCommand } from "src/dtos/create-field-metadata.dto";
-import { FieldMetadata } from "src/entities/field-metadata.entity";
 import { FieldCrudManager, ValidationError } from "src/interfaces";
 import { EntityManager, In } from "typeorm";
 
@@ -13,12 +13,15 @@ export interface OneToManyRelationFieldOptions {
     modelSingularName: string | undefined | null;
     inverseFieldName: string | undefined | null;
     entityManager: EntityManager | undefined | null;
+    isUpdate?: boolean;
+    entityId?: number;
 }
 
 const linkCommands = [RelationFieldsCommand.link, RelationFieldsCommand.unlink, RelationFieldsCommand.set];
 
 // This implementation is meant to be used for many-to-one relation field
 export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
+    private readonly logger = new Logger(OneToManyRelationFieldCrudManager.name);
 
     private readonly valueFieldName: string;
     private readonly idFieldName: string;
@@ -74,18 +77,22 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
     }
 
     async transformForCreate(dto: any): Promise<any> {
-        // const relatedFieldData: any[] = dto[this.fieldName()];
         const currentEntityName = classify(this.options.modelSingularName);
         const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
         const relatedEntityName = classify(this.options.relationCoModelSingularName);
         const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName);
 
-        dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
+        const result = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
+        if (result !== undefined) {
+            dto[this.valueFieldName] = result;
+        } else {
+            delete dto[this.valueFieldName];
+        }
         return dto;
     }
 
-    private async transformByCommand(dto: any, relatedEntityRepository: any, currentEntityRepository: any): Promise<any[]> {
+    private async transformByCommand(dto: any, relatedEntityRepository: any, currentEntityRepository: any): Promise<any[] | undefined> {
         // TODO : Need to add support for the multiple commands
         const command = dto[this.commandFieldName];
         const values = dto[this.valueFieldName];
@@ -101,13 +108,14 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
             case RelationFieldsCommand.clear:
                 return this.transformForCommandClear();
             case RelationFieldsCommand.set:
-                return await this.transformForCommandSet(ids, relatedEntityRepository, dto, currentEntityRepository);    
+                return await this.transformForCommandSet(ids, relatedEntityRepository);
             case RelationFieldsCommand.link:
-                return await this.tranformForCommandLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+                return await this.tranformForCommandLink(ids, relatedEntityRepository);
             case RelationFieldsCommand.unlink:
-                return await this.transformForCommandUnLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+                return await this.transformForCommandUnLink(ids);
             default:
-                return null; // This is equivalent to no transformation
+                this.logger.log(`Invalid command ${command}`);
+                return null;
         }
     }
 
@@ -115,46 +123,50 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
         return []
     }
 
-    private async transformForCommandSet(ids: any[], relatedEntityRepository: any, dto: any, currentEntityRepository: any): Promise<any[]> {
-        // Load the entities with the ids passed
+    private async transformForCommandSet(ids: any[], relatedEntityRepository: any): Promise<any[]> {
         const loadedEntities: any[] = await relatedEntityRepository.find({
-            where : {id: In(ids) } 
+            where : {id: In(ids) }
         })
         if (loadedEntities.length !== ids.length) {
-            throw new Error('Invalid entity ids provided for linking');
+            throw new Error('Invalid entity ids provided for set');
         }
 
         return loadedEntities;
     }
 
-    private async tranformForCommandLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
-        const tranformedRelatedFields = [];
-        // Load the entities with the ids passed
-        const loadedEntities: any[] = await relatedEntityRepository.find({
-            where : {id: In(ids) } 
-        })
-        if (loadedEntities.length !== ids.length) {
+    private async tranformForCommandLink(ids: any[], relatedEntityRepository: any): Promise<undefined> {
+        if (!this.options.isUpdate) {
+            throw new Error('Link command is only supported for update operations');
+        }
+
+        const count: number = await relatedEntityRepository.count({
+            where: { id: In(ids) }
+        });
+        if (count !== ids.length) {
             throw new Error('Invalid entity ids provided for linking');
         }
-        tranformedRelatedFields.push(...loadedEntities);
 
-        return tranformedRelatedFields;
+        await this.options.entityManager
+            .createQueryBuilder()
+            .relation(classify(this.options.modelSingularName), this.valueFieldName)
+            .of(this.options.entityId)
+            .add(ids);
+
+        return undefined;
     }
 
-    private async transformForCommandUnLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
-        if (dto.id == null) {
-            throw new Error('Entity id is required for unlinking');
-        } 
+    private async transformForCommandUnLink(ids: any[]): Promise<undefined> {
+        if (!this.options.isUpdate) {
+            throw new Error('Unlink command is only supported for update operations');
+        }
 
-        const tranformedRelatedFields = [];
-        const entityInstance = await currentEntityRepository.findOne({
-            where: {id: dto.id},
-            relations: [this.valueFieldName]
-        });
-        const filteredEntities = entityInstance[this.valueFieldName].filter((entity) => !ids.includes(entity.id));
-        tranformedRelatedFields.push(...filteredEntities);
+        await this.options.entityManager
+            .createQueryBuilder()
+            .relation(classify(this.options.modelSingularName), this.valueFieldName)
+            .of(this.options.entityId)
+            .remove(ids);
 
-        return tranformedRelatedFields;
+        return undefined;
     }
 
     private async transformForCommandCreate(values: any[], relatedEntityRepository: any): Promise<any[]> {

package/src/helpers/security.helper.ts

@@ -24,7 +24,7 @@ export function buildDefaultSecurityHeaderOptions(): Readonly<HelmetOptions> {
 
         // clickjacking defense (modern)
         "frame-ancestors": ["'none'"],
-
+        "style-src": ["'self'"],
         // add/adjust as needed for your app:
         // "script-src": ["'self'"],              // add hashes/nonces/CSPRO if needed
         // "style-src": ["'self'", "'unsafe-inline'"],

package/src/index.ts

@@ -212,16 +212,12 @@ export * from './jobs/msg91-whatsapp-subscriber.service'
 export * from './listeners/user-registration.listener'
 
 export * from './passport-strategies/google-oauth.strategy'
-export * from './passport-strategies/local.strategy'
 
 export * from './services/selection-providers/list-of-values-selection-providers.service'
 
 // seed-data
-export * from './seeders/email-template-seeder.service'
 export * from './seeders/permission-metadata-seeder.service'
-export * from './seeders/sms-template-seeder.service'
 export * from './seeders/module-metadata-seeder.service'
-export * from './seeders/user-seeder.service'
 
 // export * from './services/access-token-storage.service'
 export * from './services/action-metadata.service'