@solidstarters/solid-core 1.2.200 → 1.2.201

package/src/services/solid-ts-morph.service.ts

@@ -47,8 +47,8 @@ export class SolidTsMorphService {
             },
         });
 
-        this.logger.log(`SolidTsMorphService repoRoot = ${this.repoRoot}`);
-        Object.entries(this.workspaceMap).forEach(([k, v]) => this.logger.log(`workspace '${k}' => ${v}`));
+        this.logger.debug(`SolidTsMorphService repoRoot = ${this.repoRoot}`);
+        Object.entries(this.workspaceMap).forEach(([k, v]) => this.logger.debug(`workspace '${k}' => ${v}`));
     }
 
     // ---- repo-root discovery ----

package/src/services/user-activity-history.service.ts

@@ -1,7 +1,7 @@
-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 } from 'typeorm';
+import { EntityManager, In, Repository } from 'typeorm';
 
 import { CRUDService } from 'src/services/crud.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
@@ -19,6 +19,7 @@ import { UserActivityHistoryRepository } from 'src/repository/user-activity-hist
 @Injectable()
 export class UserActivityHistoryService extends CRUDService<UserActivityHistory> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/user-view-metadata.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 } from 'typeorm';
@@ -19,6 +19,7 @@ import { UserViewMetadataRepository } from 'src/repository/user-view-metadata.re
 @Injectable()
 export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -42,13 +43,13 @@ export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
     });
 
     if (existing) {
-      existing.layout = JSON.parse(query.layout);
+      existing.layout = query.layout;
       return await this.repo.save(existing);
     } else {
       const newEntry = this.repo.create({
         user: { id: activeUser?.sub },
         viewMetadata: { id: query.viewMetadataId },
-        layout: JSON.parse(query.layout)
+        layout: query.layout
       });
       return await this.repo.save(newEntry);
     }

package/src/services/user.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
 import { ConfigService, ConfigType } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
@@ -22,6 +22,7 @@ import { RoleMetadataRepository } from 'src/repository/role-metadata.repository'
 @Injectable()
 export class UserService extends CRUDService<User> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

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

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
@@ -7,27 +7,27 @@ 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 { classify } from '@angular-devkit/core/src/utils/strings';
 import { Locale } from 'src/entities/locale.entity';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
-import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 import { ViewMetadataRepository } from 'src/repository/view-metadata.repository';
 import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
+import { MenuItemMetadataService } from './menu-item-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
-import { MenuItemMetadataService } from './menu-item-metadata.service';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -46,6 +46,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     // @InjectRepository(ModelMetadata)
     // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    @Inject(forwardRef(() => ModelMetadataRepository))
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
     readonly moduleRef: ModuleRef

package/src/solid-core-cli-db.module.ts

@@ -4,7 +4,8 @@ import { join } from 'path';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 import { WinstonTypeORMLogger } from './winston.logger';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
-
+import { parseBooleanEnv } from './helpers/environment.helper';
+import { Logger } from 'winston';
 @Module({
     imports: [
         TypeOrmModule.forRootAsync({
@@ -47,9 +48,9 @@ import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
                     // autoLoadEntities: true,
                     entities: entities,
                     // your entities will be synced with the database (recommended: disable in prod)
-                    synchronize: Boolean(process.env.DEFAULT_DATABASE_SYNCHRONIZE),
-                    logging: Boolean(process.env.DEFAULT_DATABASE_LOGGING),
-                    // logger: new WinstonTypeORMLogger(logger),  // Pass in the custom WinstonLogger
+                    synchronize: parseBooleanEnv('DEFAULT_DATABASE_SYNCHRONIZE'),
+                    logging: parseBooleanEnv('DEFAULT_DATABASE_LOGGING'),
+                    logger: parseBooleanEnv('DEFAULT_DATABASE_LOGGING') ? new WinstonTypeORMLogger(logger) : undefined,  // Pass in the custom WinstonLogger
                     namingStrategy: new SnakeNamingStrategy(),
                     // subscribers: subscribers
                 }

package/src/solid-core.module.ts

@@ -328,6 +328,15 @@ import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
 import { MediaStorageProviderMetadataRepository } from './repository/media-storage-provider-metadata.repository';
 import { McpCommand } from './commands/mcp.command';
+import { FixturesService } from './services/fixtures.service';
+import { FixturesSetupCommand } from './commands/fixtures/fixtures-setup.command';
+import { FixturesTearDownCommand } from './commands/fixtures/fixtures-tear-down.command';
+import { DatabaseBootstrapService } from './services/database/database-bootstrap.service';
+import { SequenceNumComputedFieldProvider } from './services/computed-fields/entity/sequence-num-computed-field-provider';
+import { ModelSequence } from './entities/model-sequence.entity';
+import { ModelSequenceService } from './services/model-sequence.service';
+import { ModelSequenceController } from './controllers/model-sequence.controller';
+import { ModelSequenceRepository } from './repository/model-sequence.repository';
 
 
 @Global()
@@ -369,6 +378,7 @@ import { McpCommand } from './commands/mcp.command';
       UserActivityHistory,
       UserViewMetadata,
       ViewMetadata,
+      ModelSequence,
     ]),
     ConfigModule.forFeature(appBuilderConfig),
     ConfigModule.forFeature(commonConfig),
@@ -443,6 +453,7 @@ import { McpCommand } from './commands/mcp.command';
     UserController,
     UserViewMetadataController,
     ViewMetadataController,
+    ModelSequenceController,
   ],
   providers: [
     {
@@ -702,6 +713,13 @@ import { McpCommand } from './commands/mcp.command';
     ModuleMetadataRepository,
     ActionMetadataRepository,
     MediaStorageProviderMetadataRepository,
+    FixturesService,
+    FixturesSetupCommand,
+    FixturesTearDownCommand,
+    DatabaseBootstrapService,
+    SequenceNumComputedFieldProvider,
+    ModelSequenceService,
+    ModelSequenceRepository,
   ],
   exports: [
     AiInteractionService,

package/src/subscribers/audit.subscriber.ts

@@ -1,4 +1,4 @@
-import { Injectable, Scope } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Scope } from '@nestjs/common';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
@@ -21,6 +21,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         private readonly chatterMessageService: ChatterMessageService,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) {
@@ -61,7 +62,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         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')
         );
 

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -1,17 +1,18 @@
 import { camelize } from "@angular-devkit/core/src/utils/strings";
 import { forwardRef, Inject, Injectable, InternalServerErrorException, Logger, Scope } from "@nestjs/common";
+import { model } from "mongoose";
 import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
-import { ComputedFieldMetadata, SolidRegistry } from "src/helpers/solid-registry";
+import { ComputedFieldMetadata, SolidRegistry, TypeOrmEventContext } from "src/helpers/solid-registry";
 import { IEntityPreComputeFieldProvider } from "src/interfaces";
 import { PublisherFactory } from "src/services/queues/publisher-factory.service";
-import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+import { DataSource, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from "typeorm";
 
 // Create an interface i.e ComputedFieldEvaluationPayload which has same fields as the ComputedFieldMetadata and an additional field for the database entity
 export interface ComputedFieldEvaluationPayload extends ComputedFieldMetadata {
     databaseEntity: any;
 }
 
-@Injectable({scope: Scope.TRANSIENT})
+@Injectable({ scope: Scope.TRANSIENT })
 // @EventSubscriber()
 export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface {
     private readonly logger = new Logger(this.constructor.name);
@@ -33,54 +34,66 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
     }
 
     async beforeInsert(event: InsertEvent<any>): Promise<any> {
-        await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeInsert);
+        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const eventContext = this.sanitizeEventContext(event, 'beforeInsert');
+        await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeInsert, modelName, eventContext);
     }
 
     async beforeUpdate(event: UpdateEvent<any>): Promise<any> {
-        await this.handleComputedFieldEvaluation(event.databaseEntity, ComputedFieldTriggerOperation.beforeUpdate);
+        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const eventContext = this.sanitizeEventContext(event, 'beforeUpdate');
+        // await this.handleComputedFieldEvaluation(event.databaseEntity, ComputedFieldTriggerOperation.beforeUpdate, modelName, eventContext);
+        await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeUpdate, modelName, eventContext);
     }
 
     afterInsert(event: InsertEvent<any>) {
-        this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert);
+        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
+        const eventContext = this.sanitizeEventContext(event, 'afterInsert');
+        this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert, modelName, eventContext);
     }
 
     afterUpdate(event: UpdateEvent<any>) {
-        this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterUpdate);
+        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
+        const eventContext = this.sanitizeEventContext(event, 'afterUpdate');
+        // this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterUpdate, modelName, eventContext);
+        this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterUpdate, modelName, eventContext);
     }
 
-    afterRemove(event: any) {
-        this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterRemove);
+    afterRemove(event: RemoveEvent<any>) {
+        const modelName = camelize(event.metadata?.name ?? event.entity?.constructor?.name ?? event.databaseEntity?.constructor?.name ?? '');
+        const eventContext = this.sanitizeEventContext(event, 'afterRemove');
+        this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterRemove, modelName, eventContext);
     }
 
     //FIXME: Need to add support for beforeRemove, beforeSoftRemove, afterSoftRemove, beforeRecover, afterRecover
 
-    private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation): Promise<void> {
+    private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext): Promise<void> {
         if (!entity) {
             return;
         }
         const computedFieldsTobeEvaluated = this.getComputedFieldsForEvaluation(
             this.solidRegistry.getComputedFieldMetadata(),
             currentOperation,
-            camelize(entity.constructor.name)
+            modelName
         );
         //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
         await Promise.all(
-            computedFieldsTobeEvaluated.map(c => this.evaluateComputedField(c, entity))
+            computedFieldsTobeEvaluated.map(c => this.evaluateComputedField(this.attachContext(c, eventContext), entity))
         )
     }
 
-    private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation) {
+    private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext) {
         if (!entity) {
             return;
         }
         const computedFieldsTobeEvaluated = this.getComputedFieldsForEvaluation(
             this.solidRegistry.getComputedFieldMetadata(),
             currentOperation,
-            camelize(entity.constructor.name)
+            modelName
         );
         //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
         for (const computedField of computedFieldsTobeEvaluated) {
-            this.enqueueComputedFieldEvaluationJob(computedField, entity);
+            this.enqueueComputedFieldEvaluationJob(this.attachContext(computedField, eventContext), entity, eventContext);
         }
     }
 
@@ -114,15 +127,45 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         }
     }
 
-    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any) {
+    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any, eventContext?: any) {
         const payload = {
             ...computedField,
             databaseEntity,
+            // eventContext,
         };
-        this.publisherFactory.publish({payload}, 'ComputedFieldEvaluationPublisher')
+        this.publisherFactory.publish({ payload }, 'ComputedFieldEvaluationPublisher')
         // this.computedFieldPublisher.publish({
         //     payload
         // });
     }
 
+    private attachContext<T extends ComputedFieldMetadata<any>>(computedField: T, eventContext?: any): T {
+        if (!eventContext) return computedField;
+        return {
+            ...computedField,
+            computedFieldValueProviderCtxt: {
+                ...(computedField.computedFieldValueProviderCtxt || {}),
+            },
+            eventContext,
+        };
+    }
+
+    private sanitizeEventContext(event: any, eventType: string): TypeOrmEventContext {
+        if (!event) return undefined;
+        const base: TypeOrmEventContext = {
+            metadataName: event.metadata?.name,
+            entityId: event.entityId ?? event.entity?.id ?? event.databaseEntity?.id,
+            eventType: eventType,
+        };
+        if (event.updatedColumns) {
+            base.updatedColumns = event.updatedColumns.map((c: any) => c.propertyName);
+        }
+        if (event.updatedRelations) {
+            base.updatedRelations = event.updatedRelations.map((r: any) => r.propertyName);
+        }
+        if (event.entity) base.entity = event.entity;
+        if (event.databaseEntity) base.databaseEntity = event.databaseEntity;
+        return base;
+    }
+
 }

package/src/transformers/typeorm/local-date-time-transformer.ts

@@ -0,0 +1,30 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import timezone from "dayjs/plugin/timezone";
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+const SOLIDX_TZ = process.env.SOLIDX_TIMEZONE || "Asia/Kolkata";
+
+export const LocalDateTimeTransformer = {
+    // DB → Entity
+    from(value: Date | string | null): Date | null {
+        if (!value) return null;
+
+        // SQL Server driver may give Date or string
+        const d = dayjs(value);
+
+        // Interpret DB value as SOLIDX_TZ wall time,
+        // then convert to a real UTC instant
+        return d.tz(SOLIDX_TZ, true).utc().toDate();
+    },
+
+    // Entity → DB
+    to(value: Date | null): Date | null {
+        if (!value) return null;
+
+        // Convert the instant back into SOLIDX_TZ wall time
+        return dayjs(value).tz(SOLIDX_TZ).toDate();
+    },
+};