@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/seeders/system-fields-seeder.service.ts

@@ -1,7 +1,7 @@
 // This class will add the system fields in the field-metadata table if they are missing.
 // Fetch all the models and their fields metadata and check if the system fields are present.
 
-import { Injectable } from "@nestjs/common";
+import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
 import { ModelMetadata } from "src/entities/model-metadata.entity";
 import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
 import { FieldMetadataRepository } from "src/repository/field-metadata.repository";
@@ -9,46 +9,49 @@ import { ModelMetadataRepository } from "src/repository/model-metadata.repositor
 
 @Injectable()
 export class SystemFieldsSeederService {
-   // This service is responsible for seeding the system fields metadata for all models.
-   // It will check if the system fields are already present in the field-metadata table.
-   // If not, it will add them.
-   constructor(
-      private readonly modelHelperService: ModelMetadataHelperService,
+  private readonly logger = new Logger(SystemFieldsSeederService.name);
+  // This service is responsible for seeding the system fields metadata for all models.
+  // It will check if the system fields are already present in the field-metadata table.
+  // If not, it will add them.
+  constructor(
+    private readonly modelHelperService: ModelMetadataHelperService,
     //   @InjectRepository(ModelMetadata)
     //   private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
-      private readonly modelRepository: ModelMetadataRepository, // Replace with actual model repository type
-      private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
-   ) {}
-  
-   async seed() {
-     // Get the model repo
-     const models = await this.modelRepository.find({
-       relations: ['fields'], // Assuming 'fields' is the relation to field metadata
-     });
+    @Inject(forwardRef(() => ModelMetadataRepository))
+    private readonly modelRepository: ModelMetadataRepository, // Replace with actual model repository type
+    private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
+  ) { }
 
-     for (const model of models) {
-         // Check if the system fields are already present
-         await this.seedMissingSystemFields(model);
-      }
-   }
+  async seed() {
+    // Get the model repo
+    const models = await this.modelRepository.find({
+      relations: ['fields'], // Assuming 'fields' is the relation to field metadata
+    });
 
-    private async seedMissingSystemFields(model: ModelMetadata) {
-        const existingSystemFields = model.fields.filter(field => field.isSystem);
-        const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata();
+    for (const model of models) {
+      // Check if the system fields are already present
+      await this.seedMissingSystemFields(model);
+    }
+  }
 
-        // Find out which system fields are missing
-        const missingFields = systemFieldsMetadata.filter(
-            sysField => !existingSystemFields.some(field => field.name === sysField.name)
-        );
+  private async seedMissingSystemFields(model: ModelMetadata) {
+    this.logger.debug(`Checking system fields for model: ${model.singularName}`);
+    const existingSystemFields = model.fields.filter(field => field.isSystem);
+    const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata(model.isLegacyTable, model.isLegacyTableWithId);
+    this.logger.debug(`Model: ${model.singularName} has ${existingSystemFields.length} existing system fields.`);
+    // Find out which system fields are missing
+    const missingFields = systemFieldsMetadata.filter(
+      sysField => !existingSystemFields.some(field => field.name === sysField.name)
+    );
 
-        // If there are missing fields, add them
-        if (missingFields.length > 0) {
-            const newFields = missingFields.map(field => ({
-                ...field,
-                model: model, // Associate the field with the current model
-            }));
-            await this.fieldMetadataRepository.save(newFields);
-        }
+    // If there are missing fields, add them
+    if (missingFields.length > 0) {
+      this.logger.debug(`Seeding ${missingFields.length} missing system fields for model: ${model.singularName}`);
+      const newFields = missingFields.map(field => ({
+        ...field,
+        model: model, // Associate the field with the current model
+      }));
+      await this.fieldMetadataRepository.save(newFields);
     }
+  }
 }
-   

package/src/services/action-metadata.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
@@ -7,7 +7,7 @@ import { CRUDService } from 'src/services/crud.service';
 import { FileService } from "src/services/file.service";
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { EntityManager } from 'typeorm';
+import { EntityManager, In } from 'typeorm';
 
 
 import { ActionMetadataRepository } from 'src/repository/action-metadata.repository';
@@ -16,6 +16,7 @@ import { ActionMetadata } from '../entities/action-metadata.entity';
 @Injectable()
 export class ActionMetadataService extends CRUDService<ActionMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/ai-interaction.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
@@ -24,6 +24,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
   private readonly logger = new Logger(AiInteractionService.name);
 
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -219,7 +220,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
       throw new Error(`Invalid metadata JSON: ${e}`);
     }
 
-    const toolsInvoked = metadata['toolsInvoked'];
+    const toolsInvoked = metadata['tools_invoked'];
     if (!toolsInvoked) {
       // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
       throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_SOLID_COMMAND);

package/src/services/authentication.service.ts

@@ -571,11 +571,18 @@ export class AuthenticationService {
 
         // Validate & generate otp token for the user based on the identifier type.
         if (signInDto.type === RegistrationValidationSource.EMAIL) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         email: signInDto.identifier,
+            //     }
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    email: signInDto.identifier,
-                }
+                where: [
+                    { username: signInDto.identifier },
+                    { email: signInDto.identifier },
+                ]
             });
+
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
@@ -588,11 +595,18 @@ export class AuthenticationService {
             await this.userRepository.save(user);
             this.notifyUserOnOtpInititateLogin(user, RegistrationValidationSource.EMAIL);
         } else if (signInDto.type === RegistrationValidationSource.MOBILE) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         mobile: signInDto.identifier,
+            //     }
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    mobile: signInDto.identifier,
-                }
+                where: [
+                    { username: signInDto.identifier },
+                    { mobile: signInDto.identifier },
+                ]
             });
+
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
@@ -655,11 +669,20 @@ export class AuthenticationService {
             throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
         }
         if (confirmSignInDto.type === RegistrationValidationSource.EMAIL) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         email: confirmSignInDto.identifier,
+            //     },
+            //     relations: ['roles']
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    email: confirmSignInDto.identifier,
-                },
-                relations: ['roles']
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { email: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
             });
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
@@ -682,11 +705,20 @@ export class AuthenticationService {
             const roles = user.roles.map((role) => role.name);
             return { accessToken, refreshToken, user: { id, username, email, mobile, lastLoginProvider, roles } };
         } else if (confirmSignInDto.type === RegistrationValidationSource.MOBILE) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         mobile: confirmSignInDto.identifier,
+            //     },
+            //     relations: ['roles']
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    mobile: confirmSignInDto.identifier,
-                },
-                relations: ['roles']
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { mobile: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
             });
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_ACTIVE);

package/src/services/chatter-message-details.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef  } from "@nestjs/core";
 import { EntityManager, Repository, In } from 'typeorm';
@@ -16,6 +16,7 @@ import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-
 @Injectable()
 export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/chatter-message.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { Brackets, EntityManager, EntityMetadata } from 'typeorm';
@@ -26,6 +26,7 @@ import { RequestContextService } from './request-context.service';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
         readonly modelMetadataService: ModelMetadataService,
         readonly moduleMetadataService: ModuleMetadataService,
         readonly configService: ConfigService,
@@ -44,6 +45,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         readonly moduleRef: ModuleRef,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         readonly requestContextService: RequestContextService,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
@@ -116,7 +118,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const auditFields = model.fields.filter(field =>
             field.enableAuditTracking &&
-            !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );
 
@@ -179,7 +181,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const auditFields = modelFields.filter(field =>
             field.enableAuditTracking &&
-            !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );
 
@@ -542,7 +544,11 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             });
 
             if (coModel) {
-                const relatedEntityRepository = this.entityManager.getRepository(classify(coModelName));
+                //const relatedEntityRepository = this.entityManager.getRepository(classify(coModelName));
+                const dsName = coModel.dataSource || 'default';
+                const em = dsName === 'default' ? this.entityManager : this.moduleRef.get(`${dsName}EntityManager`, { strict: false });
+
+                const relatedEntityRepository = em.getRepository(classify(coModelName));
 
                 const relatedEntities = await relatedEntityRepository.find({
                     where: { [coModelFieldName]: { id: entityId } }

package/src/services/computed-fields/entity/alpha-num-external-id-computed-field-provider.ts

@@ -14,8 +14,7 @@ export interface AlphaNumExternalIdContext {
 
 @ComputedFieldProvider()
 @Injectable()
-export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext>
-{
+export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext> {
   constructor(
     @InjectEntityManager()
     private readonly entityManager: EntityManager
@@ -29,10 +28,11 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return 'Provider used to compute external ID for a CommonEntity with support for static or dynamic prefix.';
   }
 
-  async preComputeValue( triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
- ) {
-    const { prefix, length, dynamicFieldPrefix } =
-      computedFieldMetadata.computedFieldValueProviderCtxt;
+  async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
+  ) {
+    const { prefix, length, dynamicFieldPrefix } = computedFieldMetadata.computedFieldValueProviderCtxt;
+    const eventContext = computedFieldMetadata.eventContext;
+    const entityName = eventContext?.metadataName ?? eventContext.databaseEntity?.constructor?.name ?? '';
 
     const codeLength = length || 5;
 
@@ -46,8 +46,10 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
       }
     }
 
-    const uniqueCode = await this.generateUniqueExternalId( codeLength, triggerEntity, computedFieldMetadata.fieldName );
-    triggerEntity[computedFieldMetadata.fieldName] = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
+    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
+    const finalExternalId = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
+
+    triggerEntity[computedFieldMetadata.fieldName] = finalExternalId;
   }
 
   private generateRandomCode(length = 5): string {
@@ -59,8 +61,8 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return result;
   }
 
-  private async isExternalIdUnique( externalId: string, triggerEntity: T, fieldName: string ): Promise<boolean> {
-    const count = await this.entityManager.count(triggerEntity.constructor as any,
+  private async isExternalIdUnique(externalId: string, fieldName: string, entityName: string): Promise<boolean> {
+    const count = await this.entityManager.count(entityName as any,
       {
         where: { [fieldName]: externalId },
       }
@@ -68,13 +70,16 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return count === 0;
   }
 
-  private async generateUniqueExternalId(codeLength: number, triggerEntity: T, fieldName: string): Promise<string> {
+  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
     const maxAttempts = 10;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
+
       const newId = this.generateRandomCode(codeLength);
 
-      const isUnique = await this.isExternalIdUnique(newId,triggerEntity,fieldName);
+      const fullId = resolvedPrefix ? `${resolvedPrefix}-${newId}` : newId;
+
+      const isUnique = await this.isExternalIdUnique(fullId, fieldName, entityName);
 
       if (isUnique) {
         return newId;

package/src/services/computed-fields/entity/sequence-num-computed-field-provider.ts

@@ -0,0 +1,86 @@
+import { Injectable } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
+import { CommonEntity } from "src/entities/common.entity";
+import { ModelSequence } from "src/entities/model-sequence.entity";
+import { ComputedFieldMetadata } from "src/helpers/solid-registry";
+import { IEntityPreComputeFieldProvider } from "src/interfaces";
+import { DataSource, EntityTarget } from "typeorm";
+
+
+export interface SequenceNumComputedFieldContext {
+    sequenceName: string; // The separator to use between concatenated values
+}
+
+@ComputedFieldProvider()
+@Injectable()
+export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, SequenceNumComputedFieldContext> {
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource
+    ) { }
+
+    name(): string {
+        return "SequenceNumComputedFieldProvider";
+    }
+
+    help(): string {
+        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number.";
+    }
+
+    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>) {
+        const { sequenceName } =
+            computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
+
+        if (!sequenceName) {
+            throw new Error("sequenceName is required for sequence computation");
+        }
+
+        await this.dataSource.transaction(async (manager) => {
+            /**
+             * 1️⃣ Lock sequence row (prevents race conditions)
+             */
+            // 1️⃣ Fetch sequence row
+            const modelSequenceRepo = manager.getRepository(ModelSequence)
+            const modelSequence = await modelSequenceRepo.findOne({
+                where: { sequenceName },
+                lock: { mode: "pessimistic_write" }
+            });
+
+            if (!modelSequence) {
+                throw new Error(`ModelSequence not found for ${sequenceName}`);
+            }
+
+            // 2️⃣ Generate next sequence value
+            const nextValue = modelSequence.currentValue + 1;
+
+            const paddedValue = String(nextValue).padStart(modelSequence.padding ?? 5, "0");
+
+            const prefix = modelSequence.prefix ?? "";
+            const separator = modelSequence.separator ?? "";
+
+            const sequenceString = `${prefix}${separator}${paddedValue}`;
+
+            // 3️⃣ Duplicate check on TARGET ENTITY (extra safety)
+            const entityRepo = manager.getRepository(triggerEntity.constructor as any);
+
+            const existing = await entityRepo.findOne({
+                where: {
+                    [computedFieldMetadata.fieldName]: sequenceString,
+                },
+            });
+
+            if (existing) {
+                throw new Error(`Duplicate Sequence generated: ${sequenceString}`);
+            }
+
+            // 4️⃣ set the computed field on the entity
+            (triggerEntity as any)[computedFieldMetadata.fieldName] = sequenceString;
+
+            // 5️⃣ Persist updated sequence current value
+            modelSequence.currentValue = nextValue;
+            await modelSequenceRepo.save(modelSequence);
+        });
+    }
+
+}