@solidxai/core 0.1.4 → 0.1.5-beta.0

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'

package/src/repository/solid-base.repository.ts

@@ -13,9 +13,11 @@ import {
     FindOptionsWhere,
     QueryRunner,
     Repository,
-    SelectQueryBuilder
+    SelectQueryBuilder,
+    UpdateResult
 } from 'typeorm';
 import { SecurityRuleRepository } from './security-rule.repository';
+import { PickKeysByType } from 'typeorm/common/PickKeysByType';
 
 export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
     protected readonly logger: Logger;
@@ -132,4 +134,173 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
 
         return qb.getManyAndCount();
     }
+
+    /**
+ * Security-aware count(): applies security rules before counting.
+ */
+    override async count(options?: FindManyOptions<T>): Promise<number> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        if (options) {
+            qb.setFindOptions(options);
+        }
+
+        return qb.getCount();
+    }
+
+    /**
+     * Security-aware countBy(): convenience wrapper routed through count().
+     */
+    override async countBy(where: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<number> {
+        return this.count({ where });
+    }
+
+    /**
+ * Security-aware average(): applies security rules before computing the average.
+ */
+    override async average(columnName: PickKeysByType<T, number>, where?: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<number | null> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        if (where) {
+            qb.setFindOptions({ where });
+        }
+
+        const result = await qb
+            .select(`AVG(CAST(${alias}.${String(columnName)} AS FLOAT))`, 'avg')
+            .getRawOne<{ avg: string | number | null }>();
+
+        if (result?.avg === null || result?.avg === undefined) {
+            return null;
+        }
+
+        return typeof result.avg === 'number'
+            ? result.avg
+            : parseFloat(result.avg);
+    }
+
+    /**
+ * Security-aware sum(): applies security rules before computing the sum.
+ */
+    override async sum(columnName: PickKeysByType<T, number>, where?: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<number | null> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        if (where) {
+            qb.setFindOptions({ where });
+        }
+
+        const result = await qb
+            .select(`SUM(CAST(${alias}.${String(columnName)} AS FLOAT))`, 'sum')
+            .getRawOne<{ sum: string | number | null }>();
+
+        if (result?.sum === null || result?.sum === undefined) {
+            return null;
+        }
+
+        return typeof result.sum === 'number'
+            ? result.sum
+            : parseFloat(result.sum);
+    }
+
+    /**
+     * Security-aware minimum(): applies security rules before computing the minimum.
+     */
+    override async minimum(columnName: PickKeysByType<T, number>, where?: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<number | null> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        if (where) {
+            qb.setFindOptions({ where });
+        }
+
+        const result = await qb
+            .select(`MIN(CAST(${alias}.${String(columnName)} AS FLOAT))`, 'min')
+            .getRawOne<{ min: string | number | null }>();
+
+        if (result?.min === null || result?.min === undefined) {
+            return null;
+        }
+
+        return typeof result.min === 'number'
+            ? result.min
+            : parseFloat(result.min);
+    }
+
+    /**
+     * Security-aware maximum(): applies security rules before computing the maximum.
+     */
+    override async maximum(columnName: PickKeysByType<T, number>, where?: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<number | null> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        if (where) {
+            qb.setFindOptions({ where });
+        }
+
+        const result = await qb
+            .select(`MAX(CAST(${alias}.${String(columnName)} AS FLOAT))`, 'max')
+            .getRawOne<{ max: string | number | null }>();
+
+        if (result?.max === null || result?.max === undefined) {
+            return null;
+        }
+
+        return typeof result.max === 'number'
+            ? result.max
+            : parseFloat(result.max);
+    }
+
+    /**
+     * Security-aware increment(): increments a column by a given value for all matching rows.
+     * Security rules are applied to determine which rows the user is allowed to modify.
+     */
+    override async increment(where: FindOptionsWhere<T>, propertyPath: string, value: string | number,): Promise<UpdateResult> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        qb.setFindOptions({ where });
+
+        const rows = await qb.select(`${alias}.id`).getMany();
+        const ids = rows.map((r) => (r as any).id);
+
+        if (ids.length === 0) {
+            return { raw: [], affected: 0, generatedMaps: [] };
+        }
+
+        return this.manager
+            .createQueryBuilder()
+            .update(this.metadata.target)
+            .set({ [propertyPath]: () => `${propertyPath} + :value` } as any)
+            .whereInIds(ids)
+            .setParameter('value', value)
+            .execute();
+    }
+
+    /**
+     * Security-aware decrement(): decrements a column by a given value for all matching rows.
+     * Security rules are applied to determine which rows the user is allowed to modify.
+     */
+    override async decrement(where: FindOptionsWhere<T>, propertyPath: string, value: string | number,): Promise<UpdateResult> {
+        const alias = this.modelSingularName();
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
+
+        qb.setFindOptions({ where });
+
+        const rows = await qb.select(`${alias}.id`).getMany();
+        const ids = rows.map((r) => (r as any).id);
+
+        if (ids.length === 0) {
+            return { raw: [], affected: 0, generatedMaps: [] };
+        }
+
+        return this.manager
+            .createQueryBuilder()
+            .update(this.metadata.target)
+            .set({ [propertyPath]: () => `${propertyPath} - :value` } as any)
+            .whereInIds(ids)
+            .setParameter('value', value)
+            .execute();
+    }
 }