@solidstarters/solid-core 1.2.152 → 1.2.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.152",
+  "version": "1.2.153",
   "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/services/computed-fields/entity/alpha-num-external-id-computed-field-provider.ts

@@ -5,15 +5,17 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { ComputedFieldMetadata } from 'src/helpers/solid-registry';
 import { IEntityPreComputeFieldProvider } from 'src/interfaces';
 import { EntityManager } from 'typeorm';
-
+import { get } from "lodash";
 export interface AlphaNumExternalIdContext {
-  prefix: string; // The prefix to use for the external ID
-  length?: number; // Optional: length of the unique code to generate, default is 5
+  prefix?: string;              // alias -> staticPrefix
+  length?: number;              // Optional: length of the unique code to generate, default is 5
+  dynamicFieldPrefix?: string;  // NEW: field name on the entity
 }
 
 @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
@@ -24,14 +26,28 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
   }
 
   help(): string {
-    return 'Provider used to compute external ID for a CommonEntity.';
+    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 = computedFieldMetadata.computedFieldValueProviderCtxt.prefix;
-    const codeLength = computedFieldMetadata.computedFieldValueProviderCtxt.length || 5;
-    const uniqueCode = await this.generateUniqueExternalId(codeLength, triggerEntity, computedFieldMetadata.fieldName);
-    triggerEntity[computedFieldMetadata.fieldName] = `${prefix}-${uniqueCode}`;
+  async preComputeValue( triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
+ ) {
+    const { prefix, length, dynamicFieldPrefix } =
+      computedFieldMetadata.computedFieldValueProviderCtxt;
+
+    const codeLength = length || 5;
+
+    // Determine prefix
+    let resolvedPrefix = prefix || '';
+
+    if (dynamicFieldPrefix) {
+      const dynamicValue = get(triggerEntity as any, dynamicFieldPrefix);
+      if (dynamicValue) {
+        resolvedPrefix = String(dynamicValue).trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9\-]/g, '');
+      }
+    }
+
+    const uniqueCode = await this.generateUniqueExternalId( codeLength, triggerEntity, computedFieldMetadata.fieldName );
+    triggerEntity[computedFieldMetadata.fieldName] = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
   }
 
   private generateRandomCode(length = 5): string {
@@ -43,10 +59,12 @@ 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.name, {
-      where: { [fieldName]: externalId },
-    });
+  private async isExternalIdUnique( externalId: string, triggerEntity: T, fieldName: string ): Promise<boolean> {
+    const count = await this.entityManager.count(triggerEntity.constructor as any,
+      {
+        where: { [fieldName]: externalId },
+      }
+    );
     return count === 0;
   }
 
@@ -56,7 +74,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const newId = this.generateRandomCode(codeLength);
 
-      const isUnique = await this.isExternalIdUnique(newId, triggerEntity, fieldName);
+      const isUnique = await this.isExternalIdUnique(newId,triggerEntity,fieldName);
 
       if (isUnique) {
         return newId;
@@ -65,4 +83,4 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
 
     throw new Error('Failed to generate a unique external ID after multiple attempts');
   }
-}
+}