@solidstarters/solid-core 1.2.200 → 1.2.201

package/src/dtos/resolve-s3-url.dto.ts

@@ -7,24 +7,22 @@ export class ResolveS3UrlDto {
     @IsNotEmpty()
     fieldName: string;
 
-    @IsNotEmpty()
-    s3KeyFieldName: string;
 
     @IsNotEmpty()
-    fieldValue: string;
+    fileType?: string;
 
     @IsNotEmpty()
-    fileType: string;
-    
-    @IsNotEmpty()
-    bucketName: string;
-
-    @IsNotEmpty()
-    isPrivate: string;
-}
+    s3Key?: string;
 
+    @IsOptional()
+    bucketName?: string;
 
+    @IsOptional()
+    mediaStorageProviderUserKey?: string;
 
+    @IsNotEmpty()
+    isPrivate?: string;
+}
 
 
 

package/src/dtos/update-model-sequence.dto.ts

@@ -0,0 +1,53 @@
+import { IsInt,IsOptional, IsString, IsNotEmpty } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UpdateModelSequenceDto {
+    @IsOptional()
+    @IsInt()
+    id: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    moduleId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    moduleUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    modelId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    modelUserKey: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    fieldId: number;
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    fieldUserKey: string;
+    @IsNotEmpty()
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    sequenceName: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    currentValue: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    prefix: string;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    padding: number;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    separator: string;
+}

package/src/entities/common.entity.ts

@@ -1,4 +1,4 @@
-import { Column, CreateDateColumn, DeleteDateColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
+import { Column, CreateDateColumn, DeleteDateColumn, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
 import type { User } from "./user.entity";
 import { Exclude, Expose, Type } from "class-transformer";
 
@@ -15,6 +15,7 @@ export abstract class CommonEntity {
     updatedAt: Date;
 
     @DeleteDateColumn({ name: "deleted_at" })
+    @Index()
     deletedAt: Date;
 
     @Column({ name: "deletedTracker", default: "not-deleted" })
@@ -49,5 +50,4 @@ export abstract class CommonEntity {
     @Expose()
     @Column({ name: `updated_by_id`, nullable: true })
     updatedBy: number;
-    
 }

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

@@ -1,5 +1,5 @@
 import { Exclude, Expose, Type } from "class-transformer";
-import { Column, CreateDateColumn, DeleteDateColumn, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
+import { Column, CreateDateColumn, DeleteDateColumn, Index, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
 import type { User } from "./user.entity";
 
 export const LEGACY_TABLE_FIELDS_PREFIX = 'ss';
@@ -18,6 +18,7 @@ export abstract class LegacyCommonEntity {
     updatedAt: Date;
 
     @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at` })
+    @Index()
     deletedAt: Date;
 
     @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_tracker`, default: "not-deleted" })

package/src/entities/model-sequence.entity.ts

@@ -0,0 +1,32 @@
+import { CommonEntity } from "src/entities/common.entity"
+import { Entity, JoinColumn, ManyToOne, Index, Column } from 'typeorm';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity'
+
+@Entity('ss_model_sequence')
+export class ModelSequence extends CommonEntity {
+    @Index()
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
+    @JoinColumn()
+    module: ModuleMetadata;
+    @Index()
+    @ManyToOne(() => ModelMetadata, { nullable: false })
+    @JoinColumn()
+    model: ModelMetadata;
+    @Index()
+    @ManyToOne(() => FieldMetadata, { nullable: false })
+    @JoinColumn()
+    field: FieldMetadata;
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    sequenceName: string;
+    @Column({ type: "integer", default: 1 })
+    currentValue: number;
+    @Column({ type: "varchar", nullable: true })
+    prefix: string;
+    @Column({ type: "integer", default: 5 })
+    padding: number;
+    @Column({ type: "varchar", default: "" })
+    separator: string;
+}

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

@@ -14,13 +14,22 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     }
 
     validate(createDto: any): ValidationError[] {
-        const fieldValue: any = createDto[this.options.fieldName];
+        let fieldValue: any = createDto[this.options.fieldName];
+        if (fieldValue !== undefined && fieldValue !== null) {
+            try {
+                if (typeof fieldValue === 'string' || typeof fieldValue === 'number') {
+                    fieldValue = BigInt(fieldValue);
+                }
+            } catch (err) {
+                return [{ field: this.options.fieldName, error: 'Invalid numeric value' }];
+            }
+        }
         return this.applyValidations(fieldValue);
     }
 
     private applyValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
-        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";
         if (isNotEmpty(fieldValue)) {
             errors.push(...this.applyFormatValidations(fieldValue));
         }
@@ -29,7 +38,7 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
 
     private applyFormatValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
-        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }): "no errors";
+        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }) : "no errors";
         this.isApplyMinValidation() && !min(fieldValue, this.options.min) ? errors.push({ field: this.options.fieldName, error: 'Field value is lesser than minimum required' }) : "no errors"; //FIXME min length to be handled
         this.isApplyMaxValidation() && !max(fieldValue, this.options.max) ? errors.push({ field: this.options.fieldName, error: 'Field value is greater than maximum required' }) : "no errors";
         return errors;
@@ -43,13 +52,17 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     private isApplyMinValidation(): boolean {
         return this.options.min > 0;
     }
+
     private isApplyMaxValidation(): boolean {
         return this.options.max > 0;
     }
+
     private isApplyRequiredValidation(): boolean {
         return this.options.required;
     }
+
     private isBigInt(value: any): boolean {
-        return typeof value === 'bigint';
-      }
+        const valueType = typeof value;
+        return valueType === 'bigint' || (valueType === 'number' && Number.isFinite(value));
+    }
 }

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

@@ -68,11 +68,11 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
     }
 
     async transformForCreate(dto: any): Promise<any> {
-        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
-        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+        const currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName)
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -192,9 +192,9 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // Returns the entity target class from the entity name
-    private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const entityMetadata = entityMetadatas.find(em => em.name === entityName);
-        return entityMetadata.target;
-    }
+    // private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const entityMetadata = entityMetadatas.find(em => em.name === entityName);
+    //     return entityMetadata.target;
+    // }
 }

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

@@ -1,4 +1,5 @@
 import { classify } from "@angular-devkit/core/src/utils/strings";
+import { BadRequestException } from "@nestjs/common";
 import { isEmpty, isNotEmpty, isString } from "class-validator";
 import { FieldCrudManager, ValidationError } from "src/interfaces";
 import { IsParsableInt } from "src/validators/is-parsable-int";
@@ -64,16 +65,23 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         // Avoid transforming if both fieldId and fieldUserKey  is empty
         if ((isEmpty(fieldId)) && isEmpty(fieldUserKeyValue)) return dto;
 
+         if (!this.options.relationCoModelSingularName) {
+            throw new BadRequestException(`ManyToOneRelationFieldCrudManager: relationCoModelSingularName is not defined in the field: ${this.options.fieldName}`);
+        }
         // // Load the related entity from the database, using the repository of the related entity
-        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        const coModelEntityName = classify(this.options.relationCoModelSingularName);
+
+        //Load the related entity from the database, using the repository of the related entity
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
         if (isNotEmpty(fieldId)) {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ id: fieldId });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).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.relationCoModelSingularName}`);
             }
         }
         else {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
                 throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
@@ -88,10 +96,10 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
     }
 
     // Returns the entity target class from the entity name
-    private getRelatedEntityTarget(relatedEntityName: string): any {
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const relatedEntityMetadata = entityMetadatas.find(em => em.name === relatedEntityName);
-        return relatedEntityMetadata.target;
-    }
+    // private getRelatedEntityTarget(relatedEntityName: string): any {
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const relatedEntityMetadata = entityMetadatas.find(em => em.name === relatedEntityName);
+    //     return relatedEntityMetadata.target;
+    // }
 
 }

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

@@ -75,11 +75,11 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     async transformForCreate(dto: any): Promise<any> {
         // const relatedFieldData: any[] = dto[this.fieldName()];
-        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
-        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+        const currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName);
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -197,9 +197,9 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // Returns the entity target class from the entity name
-    private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const entityMetadata = entityMetadatas.find(em => em.name === entityName);
-        return entityMetadata.target;
-    }
+    // private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const entityMetadata = entityMetadatas.find(em => em.name === entityName);
+    //     return entityMetadata.target;
+    // }
 }

package/src/helpers/model-metadata-helper.service.ts

@@ -1,18 +1,20 @@
 // Return the system fields metadata for a model
 
-import { Injectable, Logger } from "@nestjs/common";
+import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
+import { _ } from "lodash";
+import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
 import { SolidRegistry } from "./solid-registry";
-import {_ } from "lodash";
-import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 
 @Injectable()
 export class ModelMetadataHelperService {
     private readonly logger = new Logger(ModelMetadataHelperService.name);
 
-    constructor(private readonly registry: SolidRegistry,
+    constructor(
+        private readonly registry: SolidRegistry,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
     ) {
     }

package/src/helpers/module-metadata-helper.service.ts

@@ -57,4 +57,21 @@ export class ModuleMetadataHelperService {
         }
         return filePath;
     }
-}
+    async getModuleMetadataFolderPath(moduleName: string): Promise<string> {
+        if (!moduleName) {
+            return '';
+        }
+
+        const dashModuleName = dasherize(moduleName);
+
+        const folderPath = path.resolve(
+            process.cwd(),
+            'module-metadata',
+            dashModuleName,
+        );
+
+        const exists = await this.fileService.pathExists(folderPath);
+        return exists ? folderPath : '';
+    }
+
+}

package/src/helpers/module.helper.ts

@@ -1,6 +1,8 @@
+import { Logger } from '@nestjs/common';
 import * as fs from 'fs'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
 
+const logger = new Logger('module.helper');
 
 export const getDynamicModuleNames = (): string[] => {
   const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
@@ -21,15 +23,48 @@ export const getDynamicModuleNames = (): string[] => {
 
       if (!isValidDirectory) return false;
 
-      return true
-      // const fullPath = path.join(srcPath, dirent.name);
-      // const files = fs.readdirSync(fullPath);
+      // return true
+      const fullPath = path.join(srcPath, dirent.name);
+      const files = fs.readdirSync(fullPath);
       // skip if empty directory
-      // return files.length > 0;
+      return files.length > 0;
     })
     .map(dirent => dirent.name);
 
-  console.log(`Enabled dynamic modules:`, enabledModules);
+  // logger.debug(`Enabled dynamic modules:`, enabledModules);
+  return enabledModules;
+}
+
+export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
+  const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+
+  // Find a path that is ../${srcPath}/module-metadata save it in a variable.
+  // const srcPath = path.join(process.cwd(), 'src');
+  const moduleMetadataPath = path.join(process.cwd(), 'module-metadata');
+  const coreModuleNames = getCoreModuleNames();
+  const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+
+  // if module-metadata path does not exist, return empty array
+  if (!fs.existsSync(moduleMetadataPath)) {
+    logger.warn(`Module metadata path does not exist: ${moduleMetadataPath}`);
+    return [];
+  }
+
+  const moduleMetadataDirectories = fs.readdirSync(moduleMetadataPath, { withFileTypes: true });
+  const enabledModules = moduleMetadataDirectories
+    .filter(dirent => {
+      const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
+
+      if (!isValidDirectory) return false;
+
+      const fullPath = path.join(moduleMetadataPath, dirent.name, `${dirent.name}-metadata.json`);
+
+      const stats = fs.statSync(fullPath, { throwIfNoEntry: false });
+      return !!stats && stats.isFile();
+    })
+    .map(dirent => dirent.name);
+
+  // logger.debug(`Enabled dynamic modules basis src:`, enabledModules);
   return enabledModules;
 }
 

package/src/helpers/solid-registry.ts

@@ -7,6 +7,9 @@ import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
 import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
 import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { ObjectLiteral } from 'typeorm';
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
 
 type ControllerMetadata = {
   name: string;
@@ -39,6 +42,16 @@ export enum RESERVED_SOLID_KEYWORDS {
   locale = "locale"
 }
 
+export interface TypeOrmEventContext {
+  eventType?: string;
+  entity?: ObjectLiteral | undefined;
+  databaseEntity?: any;
+  entityId?: any;
+  metadataName?: string;
+  updatedColumns?: string[];
+  updatedRelations?: string[];
+}
+
 export interface ComputedFieldMetadata<TContext = any> {
   moduleName: string; // Name of the module where the computed field is defined
   modelName: string; // Name of the model where the computed field is defined
@@ -49,6 +62,7 @@ export interface ComputedFieldMetadata<TContext = any> {
   computedFieldValueProviderName: string; // Name of the provider that computes the field value
   // Example: '{"contextKey": "contextValue"}'
   computedFieldValueProviderCtxt: TContext; // Context for the computed field value
+  eventContext: TypeOrmEventContext;
 }
 
 @Injectable()

package/src/index.ts

@@ -137,6 +137,7 @@ export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
+export * from './entities/model-sequence.entity'
 
 export * from './enums/auth-type.enum'
 export * from './decorators/disallow-in-production.decorator'
@@ -299,6 +300,8 @@ export * from './subscribers/audit.subscriber'
 export * from './transformers/array-transformer'
 export * from './transformers/boolean-transformer'
 export * from './transformers/integer-transformer'
+export { default as datetimeTransformer } from './transformers/datetime-transformer'
+export * from './transformers/typeorm/local-date-time-transformer'
 
 export * from './validators/is-parsable-int'
 
@@ -307,6 +310,5 @@ export * from './interfaces'
 export * from './solid-core.module'
 
 export * from './winston.logger'
-export { default as datetimeTransformer } from './transformers/datetime-transformer'
 
 export { ERROR_MESSAGES } from './constants/error-messages'

package/src/jobs/computed-field-evaluation-subscriber.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable, Logger } from "@nestjs/common";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "src/interfaces";
 import { QueueMessage } from "src/interfaces/mq";
@@ -11,6 +11,7 @@ import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-que
 
 @Injectable()
 export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscriber<ComputedFieldEvaluationPayload> {
+    private readonly _logger = new Logger(ComputedFieldEvaluationSubscriberRabbitmq.name);
     constructor(
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
@@ -30,9 +31,19 @@ export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscribe
     // It will then call the corresponding provider computeAndSave method to perform the evaluation
     async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
         const { databaseEntity, ...computedFieldMetadata } = message.payload;
-        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
+        const { computedFieldValueProviderName } = computedFieldMetadata;
+        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldValueProviderName);
         // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
         const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider
-        await providerInstance.postComputeAndSaveValue(databaseEntity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+        if (typeof providerInstance.postComputeAndSaveValue !== 'function') {
+            this._logger.warn(`Provider "${computedFieldValueProviderName}" does not implement postComputeAndSaveValue; skipping post-compute.`);
+            return;
+        }
+        await providerInstance.postComputeAndSaveValue(databaseEntity, {
+            ...computedFieldMetadata,
+            computedFieldValueProviderCtxt: {
+                ...(computedFieldMetadata.computedFieldValueProviderCtxt || {}),
+            },
+        }); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
     }
-}
+}

package/src/repository/media.repository.ts

@@ -1,7 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { Media } from 'src/entities/media.entity';
 import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
+import { DataSource, In } from 'typeorm';
 import { FieldMetadataRepository } from './field-metadata.repository';
 import { MediaStorageProviderMetadataRepository } from './media-storage-provider-metadata.repository';
 import { ModelMetadataRepository } from './model-metadata.repository';
@@ -21,6 +21,7 @@ export class MediaRepository extends SolidBaseRepository<Media> {
         // @InjectRepository(MediaStorageProviderMetadata)
         // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
         private readonly fieldMetadataRepo: FieldMetadataRepository,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
     ) {

package/src/repository/model-sequence.repository.ts

@@ -0,0 +1,97 @@
+import { Injectable } from '@nestjs/common';
+import { ModelSequence } from 'src/entities/model-sequence.entity';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { CreateModelSequenceDto } from 'src/dtos/create-model-sequence.dto';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+
+@Injectable()
+export class ModelSequenceRepository extends SolidBaseRepository<ModelSequence> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModelSequence, dataSource, requestContextService, securityRuleRepository);
+    }
+
+    async upsertWithDto(createDto: CreateModelSequenceDto) {
+        // Populate the module from moduleId or moduleUserKey
+        const moduleRepository = this.dataSource.getRepository(ModuleMetadata);
+        if (createDto.moduleId) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    id: createDto.moduleId,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        if (createDto.moduleUserKey) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    name: createDto.moduleUserKey,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        // Populate the model from modelId or modelUserKey
+        const modelRepository = this.dataSource.getRepository(ModelMetadata);
+        if (createDto.modelId) {
+            const model = await modelRepository.findOne({
+                where: {
+                    id: createDto.modelId,
+                },
+            });
+            createDto['model'] = model;
+        }
+        if (createDto.modelUserKey) {
+            const model = await modelRepository.findOne({
+                where: {
+                    singularName: createDto.modelUserKey,
+                },
+            });
+            createDto['model'] = model;
+        }
+
+        // Populate the field from fieldId or fieldUserKey
+        const fieldRepository = this.dataSource.getRepository(FieldMetadata);
+        if (createDto.fieldId) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    id: createDto.fieldId,
+                },
+            });
+            createDto['field'] = field;
+        }
+        if (createDto.fieldUserKey) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    name: createDto.fieldUserKey,
+                },
+            });
+            createDto['field'] = field;
+        }
+
+        // First check if sequence already exists using name
+        const existingModelSequence = await this.findOne({
+            where: {
+                sequenceName: createDto.sequenceName,
+            },
+        });
+
+        if (existingModelSequence) {
+            const updatedModelSequence = this.merge(existingModelSequence, createDto);
+            return this.save(updatedModelSequence);
+        }
+        else {
+            const modelSequence = this.create(createDto);
+            return this.save(modelSequence);
+        }
+    }
+}