@solidxai/core 0.1.11-beta.0 → 0.1.11-beta.11

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

@@ -2,7 +2,7 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { join, dirname, normalize, isAbsolute, basename } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { Project, Node, ObjectLiteralExpression, ArrayLiteralExpression, QuoteKind, IndentationText } from "ts-morph";
+import { Project, Node, ObjectLiteralExpression, ArrayLiteralExpression, QuoteKind, IndentationText, SyntaxKind } from "ts-morph";
 import { MethodDeclarationStructure, StructureKind } from "ts-morph";
 
 type Bucket = "imports" | "providers" | "exports";
@@ -468,6 +468,66 @@ export class SolidTsMorphService {
         return { staged: true, overwritten: false, skipped: false };
     }
 
+    cleanupTypeormDatasourceEntity(
+        filePath: string,
+        entityImportPath: string,
+        entityClassName: string,
+    ): { staged: boolean; skipped: boolean; removedImport: boolean; removedEntity: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs)) {
+            this.logger.warn(`cleanupTypeormDatasourceEntity: file not found at ${filePath}, skipping.`);
+            return { staged: false, skipped: true, removedImport: false, removedEntity: false };
+        }
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        let removedImport = false;
+        let removedEntity = false;
+
+        const importDeclaration = sourceFile.getImportDeclarations().find((declaration) =>
+            declaration.getModuleSpecifierValue().replace(/\\/g, "/") === entityImportPath.replace(/\\/g, "/"),
+        );
+
+        if (importDeclaration) {
+            const namedImport = importDeclaration.getNamedImports().find((named) => named.getName() === entityClassName);
+            if (namedImport) {
+                namedImport.remove();
+                removedImport = true;
+            }
+
+            if (
+                importDeclaration.getNamedImports().length === 0 &&
+                !importDeclaration.getDefaultImport() &&
+                !importDeclaration.getNamespaceImport()
+            ) {
+                importDeclaration.remove();
+            }
+        }
+
+        const entitiesDeclaration = sourceFile.getVariableDeclaration("entities");
+        const entitiesArray = entitiesDeclaration?.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+        if (entitiesArray) {
+            const elements = entitiesArray.getElements();
+            for (let i = elements.length - 1; i >= 0; i--) {
+                if (elements[i].getText().replace(/\s+/g, "") === entityClassName) {
+                    entitiesArray.removeElement(i);
+                    removedEntity = true;
+                }
+            }
+        }
+
+        if (!removedImport && !removedEntity) {
+            return { staged: false, skipped: true, removedImport, removedEntity };
+        }
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged datasource cleanup in ${this.rel(abs)} for entity ${entityClassName}`);
+        return { staged: true, skipped: false, removedImport, removedEntity };
+    }
+
 
 
 }

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

@@ -21,6 +21,74 @@ import { MenuItemMetadata } from 'src/entities/menu-item-metadata.entity';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
+  private readonly comparableFields = [
+    'name',
+    'displayName',
+    'type',
+    'context',
+    'layout',
+    'module',
+    'model',
+  ] as const;
+  private readonly relationCompareFields = new Set(['module', 'model']);
+  private readonly jsonCompareFields = new Set(['layout', 'context']);
+
+  private normalizeJsonFieldValue(value: any): any {
+    if (typeof value === 'string') {
+      const trimmedValue = value.trim();
+      if (
+        (trimmedValue.startsWith('{') && trimmedValue.endsWith('}')) ||
+        (trimmedValue.startsWith('[') && trimmedValue.endsWith(']'))
+      ) {
+        try {
+          return this.normalizeJsonFieldValue(JSON.parse(trimmedValue));
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeJsonFieldValue(item));
+    }
+
+    if (value && typeof value === 'object') {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = this.normalizeJsonFieldValue(value[key]);
+          return result;
+        }, {} as Record<string, any>);
+    }
+
+    return value;
+  }
+
+  private getCanonicalJsonFieldString(value: any): string {
+    return JSON.stringify(this.normalizeJsonFieldValue(value) ?? null);
+  }
+
+  private hasChanges(existingSolidView: ViewMetadata, updateSolidViewDto: UpdateViewMetadataDto): boolean {
+    return this.comparableFields.some((key) => {
+      const value = (updateSolidViewDto as any)[key];
+      if (typeof value === 'undefined') {
+        return false;
+      }
+
+      if (this.relationCompareFields.has(key)) {
+        const relationValue = value as any;
+        return (existingSolidView as any)[key]?.id !== relationValue?.id;
+      }
+
+      if (this.jsonCompareFields.has(key)) {
+        return this.getCanonicalJsonFieldString((existingSolidView as any)[key]) !== this.getCanonicalJsonFieldString(value);
+      }
+
+      return (existingSolidView as any)[key] !== value;
+    });
+  }
+
   constructor(
     readonly actionMetadataService: ActionMetadataService,
     readonly menuItemMetadataService: MenuItemMetadataService,
@@ -83,15 +151,11 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       return { records: [], defaultEntityLocaleId: null };
     }
 
-    const defaultLocale = await this.entityManager.getRepository(Locale).findOne({ where: { isDefault: true } });
-
-    let defaultEntityLocaleId: string;
-    if (entityRecord.localeName === defaultLocale?.locale) {
-      defaultEntityLocaleId = entityRecord.id;
-      this.logger.debug(`Editing default locale record with id ${defaultEntityLocaleId}`);
+    const defaultEntityLocaleId = entityRecord.defaultEntityLocaleId || entityRecord.id;
+    if (entityRecord.defaultEntityLocaleId) {
+      this.logger.debug(`Editing translated locale record. Translation root id: ${defaultEntityLocaleId}`);
     } else {
-      defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
-      this.logger.debug(`Editing non-default locale record. DefaultEntityLocaleId: ${defaultEntityLocaleId}`);
+      this.logger.debug(`Editing translation root record with id ${defaultEntityLocaleId}`);
     }
 
     const records = await currentEntityRepository.find({
@@ -438,10 +502,20 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
 
   async upsert(updateSolidViewDto: UpdateViewMetadataDto) {
     // First check if module already exists using name
-    const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name);
+    const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name, {
+      module: true,
+      model: true,
+    });
 
     // if found
     if (existingSolidView) {
+      const hasChanges = this.hasChanges(existingSolidView, updateSolidViewDto);
+
+      if (!hasChanges) {
+        this.logger.debug(`Skipping view upsert for ${updateSolidViewDto.name}; no changes detected.`);
+        return existingSolidView;
+      }
+
       const updatedSolidViewDto = { ...existingSolidView, ...updateSolidViewDto };
       return this.repo.save(updatedSolidViewDto);
     }

package/src/solid-core.module.ts

@@ -13,6 +13,7 @@ import {
 import { MulterModule } from "@nestjs/platform-express";
 import { TypeOrmModule } from "@nestjs/typeorm";
 import { RemoveFieldsCommand } from "./commands/remove-fields.command";
+import { MigrateRemovedFieldsCommand } from "./commands/migrate-removed-fields.command";
 import { FieldMetadataController } from "./controllers/field-metadata.controller";
 import { DashboardController } from "./controllers/dashboard.controller";
 import { MediaStorageProviderMetadataController } from "./controllers/media-storage-provider-metadata.controller";
@@ -47,6 +48,7 @@ import { ListOfValuesService } from "./services/list-of-values.service";
 import { MediaStorageProviderMetadataService } from "./services/media-storage-provider-metadata.service";
 import { MediaService } from "./services/media.service";
 import { ModelMetadataService } from "./services/model-metadata.service";
+import { RemovedFieldMigrationService } from "./services/removed-field-migration.service";
 import { ModuleMetadataExplorerService } from "./services/module-metadata-explorer.service";
 import { ModuleMetadataService } from "./services/module-metadata.service";
 import { ModulePackageService } from "./services/module-package.service";
@@ -545,6 +547,7 @@ import { PostgresDatasourceIntrospectionProviderService } from "./services/datas
     FieldMetadataService,
     DashboardRuntimeService,
     RemoveFieldsCommand,
+    MigrateRemovedFieldsCommand,
     RefreshModelCommand,
     RefreshModuleCommand,
     InfoCommand,
@@ -791,6 +794,7 @@ import { PostgresDatasourceIntrospectionProviderService } from "./services/datas
     UserViewMetadataRepository,
     ModelMetadataRepository,
     ModuleMetadataRepository,
+    RemovedFieldMigrationService,
     ActionMetadataRepository,
     MediaStorageProviderMetadataRepository,
     FixturesService,

package/src/subscribers/audit.subscriber.ts

@@ -1,12 +1,15 @@
 import { Injectable, Logger, Scope } from '@nestjs/common';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DataSource, EntityMetadata, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
 import { AuditQueuePayload } from 'src/interfaces';
+import { isEmbeddedDb } from 'src/helpers/environment.helper';
 import { RequestContextService } from 'src/services/request-context.service';
 import { PublisherFactory } from 'src/services/queues/publisher-factory.service';
+const AUDIT_BEFORE_SNAPSHOT = '__auditBeforeSnapshot';
 
-@Injectable({scope: Scope.TRANSIENT})
+@Injectable({ scope: Scope.TRANSIENT })
 export class AuditSubscriber implements EntitySubscriberInterface {
     private readonly logger = new Logger(AuditSubscriber.name);
     private dataSource: DataSource;
@@ -14,6 +17,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         private readonly publisherFactory: PublisherFactory<AuditQueuePayload>,
         private readonly solidRegistry: SolidRegistry,
         private readonly requestContextService: RequestContextService,
+        private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) { }
 
     bindToDataSource(dataSource: DataSource) {
@@ -53,20 +57,85 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
     async afterUpdate(event: UpdateEvent<any>) {
         if (!this.shouldTrackAudit(event.metadata)) return;
+        const entityId = event.entity?.id ?? event.databaseEntity?.id ?? (event as any).entityId ?? null;
+        let before = event.databaseEntity ?? null;
+        let after = event.entity ?? null;
+        const updatedColumnNames = (event.updatedColumns ?? []).map(c => c.propertyName);
+
+        const auditResult = await this.prepareManyToManyAuditUpdateSnapshot(event, entityId, updatedColumnNames);
+
+        if (auditResult) {
+            before = auditResult.before;
+            after = auditResult.after;
+        }
+
         this.enqueue(event, {
             eventType: 'update',
             modelName: event.metadata.name,
-            entityId: event.entity?.id ?? null,
+            entityId: entityId,
             occurredAt: new Date().toISOString(),
-            after: event.entity ?? null,
+            after: after,
             // databaseEntity is only populated when the entity was fetched first (save() path).
             // QueryBuilder update() leaves this undefined; postAuditMessageOnUpdate guards for it.
-            before: event.databaseEntity ?? null,
-            updatedColumnNames: (event.updatedColumns ?? []).map(c => c.propertyName),
+            before: before,
+            updatedColumnNames: updatedColumnNames,
             userId: this.activeUserId(),
         });
     }
 
+    /**
+     * Resolves before/after snapshots for audit-enabled many-to-many relations
+     * and updates changed relation field names for audit tracking.
+     */
+    private async prepareManyToManyAuditUpdateSnapshot(event: UpdateEvent<any>, entityId: number | null, updatedColumnNames: string[]): Promise<{ before: any; after: any } | null> {
+
+        // On embedded PGlite, pass the transaction's manager so the query runs
+        // on the active connection. On regular Postgres, use the default DataSource.
+        const mgr = isEmbeddedDb() ? event.manager : this.dataSource;
+        const auditRelationFields = (await this.modelMetadataHelperService.loadFieldHierarchy(lowerFirst(event.metadata.name), isEmbeddedDb() ? event.manager : undefined)).filter(field =>
+            field.enableAuditTracking &&
+            field.type === 'relation' &&
+            field.relationType !== 'one-to-many'
+        );
+
+        if (!entityId || auditRelationFields.length === 0) {
+            return null;
+        }
+
+        const relations: Record<string, boolean> = {};
+
+        auditRelationFields.forEach(field => {
+            relations[field.name] = true;
+        });
+
+        const relationBefore = event.entity?.[AUDIT_BEFORE_SNAPSHOT] ?? null;
+
+        const relationAfter = await mgr.getRepository(event.metadata.target as any).findOne({
+            where: { id: entityId } as any,
+            relations: relations as any,
+        });
+
+        if (relationBefore && relationAfter) {
+            auditRelationFields.forEach(field => {
+                const oldIds = Array.isArray(relationBefore[field.name])
+                    ? relationBefore[field.name].map(item => item.id).sort()
+                    : [];
+
+                const newIds = Array.isArray(relationAfter[field.name])
+                    ? relationAfter[field.name].map(item => item.id).sort()
+                    : [];
+
+                if ((oldIds.length !== newIds.length || JSON.stringify(oldIds) !== JSON.stringify(newIds))
+                    && !updatedColumnNames.includes(field.name)) {
+                    updatedColumnNames.push(field.name);
+                }
+            });
+        }
+        return {
+            before: relationBefore ?? event.databaseEntity ?? null,
+            after: relationAfter ?? event.entity ?? null,
+        };
+    }
     async afterRemove(event: RemoveEvent<any>) {
         if (!this.shouldTrackAudit(event.metadata)) return;
         this.enqueue(event, {
@@ -84,24 +153,38 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         const batch = this.perTxn.get(event.queryRunner) ?? [];
         this.perTxn.delete(event.queryRunner);
 
-        // Now outside the DB transaction — safe to publish to the queue.
-        // allSettled: publish in parallel; a single failure does not block the rest.
-        const results = await Promise.allSettled(
-            batch.map(payload => this.publisherFactory.publish({ payload }, 'ChatterQueuePublisher'))
-        );
+        if (batch.length === 0) return;
 
-        results.forEach((result, i) => {
-            if (result.status === 'rejected') {
-                this.logger.error(
-                    `Failed to publish audit event for ${batch[i].modelName}#${batch[i].entityId}`,
-                    result.reason,
-                );
-            }
-        });
+        if (isEmbeddedDb()) {
+            setImmediate(() => void this.publishAuditBatch(batch));
+            return;
+        }
+
+        await this.publishAuditBatch(batch);
     }
 
     afterTransactionRollback(event: { queryRunner: any }) {
         // Drop buffered payloads; the write never happened.
         this.perTxn.delete(event.queryRunner);
     }
+
+    private async publishAuditBatch(batch: AuditQueuePayload[]) {
+        try {
+            // allSettled: publish in parallel; a single failure does not block the rest.
+            const results = await Promise.allSettled(
+                batch.map(payload => this.publisherFactory.publish({ payload }, 'ChatterQueuePublisher'))
+            );
+
+            results.forEach((result, i) => {
+                if (result.status === 'rejected') {
+                    this.logger.error(
+                        `Failed to publish audit event for ${batch[i].modelName}#${batch[i].entityId}`,
+                        result.reason,
+                    );
+                }
+            });
+        } catch (error) {
+            this.logger.error('Failed to publish audit batch', error);
+        }
+    }
 }

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

@@ -1,8 +1,7 @@
 import { camelCase } from 'lodash';
-import { Delete } from "@aws-sdk/client-s3";
 import { forwardRef, Inject, Injectable, InternalServerErrorException, Logger, Scope } from "@nestjs/common";
-import { model } from "mongoose";
 import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
+import { isEmbeddedDb } from "src/helpers/environment.helper";
 import { ComputedFieldMetadata, SolidRegistry, TypeOrmEventContext } from "src/helpers/solid-registry";
 import { IEntityPreComputeFieldProvider } from "src/interfaces";
 import { PublisherFactory } from "src/services/queues/publisher-factory.service";
@@ -14,19 +13,22 @@ export interface ComputedFieldEvaluationPayload extends ComputedFieldMetadata {
 }
 
 @Injectable({ scope: Scope.TRANSIENT })
-// @EventSubscriber()
 export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface {
     private readonly logger = new Logger(this.constructor.name);
     private dataSource: DataSource;
+
+    // Per-transaction buffer for post-event evaluation jobs. Entries are
+    // flushed in afterTransactionCommit so the publish (which uses the
+    // default DataSource) never races the in-flight transaction's connection.
+    // On PGlite (pool size 1), the flush is deferred via setImmediate to
+    // ensure the transaction's connection has been released first.
+    private perTxn = new WeakMap<any, { computedField: ComputedFieldMetadata<any>; databaseEntity: any }[]>();
+
     constructor(
-        // @InjectDataSource()
-        // private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
         @Inject(forwardRef(() => PublisherFactory))
         private readonly publisherFactory: PublisherFactory<ComputedFieldEvaluationPayload>
-        // private readonly computedFieldPublisher: ComputedFieldEvaluationPublisherDatabase,
     ) {
-        // this.dataSource.subscribers.push(this);
     }
 
     bindToDataSource(dataSource: DataSource) {
@@ -43,47 +45,97 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
     async beforeUpdate(event: UpdateEvent<any>): Promise<any> {
         const modelName = camelCase(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>) {
         const modelName = camelCase(event.metadata?.name ?? event.entity?.constructor?.name ?? '');
         const eventContext = this.sanitizeEventContext(event, 'afterInsert');
-        this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert, modelName, eventContext);
+        this.handlePostEventJobs(event, event.entity, ComputedFieldTriggerOperation.afterInsert, modelName, eventContext);
     }
 
     afterUpdate(event: UpdateEvent<any>) {
         const modelName = camelCase(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);
+        this.handlePostEventJobs(event, event.entity, ComputedFieldTriggerOperation.afterUpdate, modelName, eventContext);
     }
 
     afterRemove(event: RemoveEvent<any>) {
         const modelName = camelCase(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);
+        this.handlePostEventJobs(event, event.databaseEntity, ComputedFieldTriggerOperation.afterRemove, modelName, eventContext);
     }
 
     //FIXME: Need to add support for beforeRemove, beforeSoftRemove, afterSoftRemove, beforeRecover, afterRecover
 
-    private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext): Promise<void> {
-        if (!entity) {
-            return;
-        }
+    // --------- post-event dispatch (pglite vs non-pglite) ----------
+
+    /**
+     * On embedded PGlite (pool size 1): buffer payloads on the queryRunner and
+     * flush in afterTransactionCommit (deferred via setImmediate) so the publish
+     * never tries to get a second connection while the transaction is active.
+     *
+     * On regular Postgres: fire-and-forget publish immediately (original behaviour),
+     * since the pool has spare connections.
+     */
+    private handlePostEventJobs(
+        event: InsertEvent<any> | UpdateEvent<any> | RemoveEvent<any>,
+        entity: any,
+        currentOperation: ComputedFieldTriggerOperation,
+        modelName: string,
+        eventContext?: TypeOrmEventContext,
+    ) {
+        if (!entity) return;
+
         const computedFieldsTobeEvaluated = this.getComputedFieldsForEvaluation(
             this.solidRegistry.getComputedFieldMetadata(),
             currentOperation,
             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) {
-            await this.evaluateComputedField(this.attachContext(computedField, eventContext), entity, currentOperation);
+        if (computedFieldsTobeEvaluated.length === 0) return;
+
+        if (isEmbeddedDb()) {
+            const qr = event.queryRunner;
+            const arr = this.perTxn.get(qr) ?? [];
+            for (const computedField of computedFieldsTobeEvaluated) {
+                arr.push({
+                    computedField: this.attachContext(computedField, eventContext),
+                    databaseEntity: entity,
+                });
+            }
+            this.perTxn.set(qr, arr);
+        } else {
+            for (const computedField of computedFieldsTobeEvaluated) {
+                this.enqueueComputedFieldEvaluationJob(
+                    this.attachContext(computedField, eventContext),
+                    entity,
+                );
+            }
         }
     }
 
-    private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext) {
+    // --------- transaction lifecycle (pglite only) ----------
+    async afterTransactionCommit(event: { queryRunner: any }) {
+        const batch = this.perTxn.get(event.queryRunner) ?? [];
+        this.perTxn.delete(event.queryRunner);
+        if (batch.length === 0) return;
+
+        // Deferred via setImmediate so the transaction's connection is released
+        // back to the (size-1) pool before the publish tries to acquire it.
+        setImmediate(() => void this.flushBatch(batch));
+    }
+
+    afterTransactionRollback(event: { queryRunner: any }) {
+        this.perTxn.delete(event.queryRunner);
+    }
+
+    private async flushBatch(batch: { computedField: ComputedFieldMetadata<any>; databaseEntity: any }[]) {
+        for (const { computedField, databaseEntity } of batch) {
+            this.enqueueComputedFieldEvaluationJob(computedField, databaseEntity);
+        }
+    }
+
+    private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext): Promise<void> {
         if (!entity) {
             return;
         }
@@ -92,9 +144,8 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
             currentOperation,
             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(this.attachContext(computedField, eventContext), entity, eventContext);
+            await this.evaluateComputedField(this.attachContext(computedField, eventContext), entity, currentOperation);
         }
     }
 
@@ -147,16 +198,14 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         }
     }
 
-    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any, eventContext?: any) {
+    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any) {
+        const { manager: _manager, ...serializableEventContext } = computedField.eventContext ?? {};
         const payload = {
             ...computedField,
+            eventContext: serializableEventContext,
             databaseEntity,
-            // eventContext,
         };
-        this.publisherFactory.publish({ payload }, 'ComputedFieldEvaluationPublisher')
-        // this.computedFieldPublisher.publish({
-        //     payload
-        // });
+        this.publisherFactory.publish({ payload }, 'ComputedFieldEvaluationPublisher');
     }
 
     private attachContext<T extends ComputedFieldMetadata<any>>(computedField: T, eventContext?: any): T {
@@ -175,6 +224,10 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         const base: TypeOrmEventContext = {
             metadataName: event.metadata?.name,
             eventType: eventType,
+            // Only pass the transaction's EntityManager for embedded DB (PGlite),
+            // where a second pooled connection mid-transaction would deadlock.
+            // On regular Postgres, providers use their injected EntityManager.
+            ...(isEmbeddedDb() ? { manager: event.manager } : {}),
         };
         if ("entityId" in event && event.entityId) {
             base.entityId = event.entityId;

package/src/subscribers/created-by-updated-by.subscriber.ts

@@ -38,6 +38,9 @@ export class CreatedByUpdatedBySubscriber implements EntitySubscriberInterface {
             return;
         }
 
+        // NOTE: If re-enabling loadUser below, query via `event.queryRunner.manager`, NOT
+        // `this.defaultDataSource.getRepository(...)`. A second connection opened mid-transaction
+        // deadlocks single-threaded engines (PGlite).
         // const loadedUser = await this.loadUser(activeUserOrUndefined as unknown as ActiveUserData);
         // if (isInsert) {
         //     event.entity.createdBy = loadedUser?.id;

package/src/subscribers/field-metadata.subscriber.ts

@@ -21,6 +21,9 @@ export class FieldMetadataSubscriber implements EntitySubscriberInterface<FieldM
   }
 
   async afterUpdate(event: UpdateEvent<FieldMetadata>): Promise<void> {
+    // NOTE: If re-enabling the block below, use `event.queryRunner.manager` (the active
+    // transaction's connection), NOT `this.dataSource.getRepository(...)`. A second
+    // connection opened here mid-transaction deadlocks single-threaded engines (PGlite).
     // If a field of type relation.many-to-one is marked for removal, and this field had an inverse relation created 
     // It means there is a field of type relation.one-to-many in the co-model, which needs to be removed
     // if (event.entity && event.entity.isMarkedForRemoval && event.entity.type === 'relation' && event.entity.relationType === 'many-to-one' && event.entity.relationCreateInverse === true) {

package/src/subscribers/scheduled-job.subscriber.ts

@@ -4,6 +4,7 @@ import * as fs from "fs/promises";
 import { CreateScheduledJobDto } from "src/dtos/create-scheduled-job.dto";
 import { ModuleMetadata } from "src/entities/module-metadata.entity";
 import { ScheduledJob } from "src/entities/scheduled-job.entity";
+import { isEmbeddedDb } from "src/helpers/environment.helper";
 import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
 import { ScheduledJobRepository } from "src/repository/scheduled-job.repository";
 import {
@@ -83,7 +84,7 @@ export class ScheduledJobSubscriber
       return;
     }
 
-    const moduleMetadataRepo = event.queryRunner.manager.getRepository(ModuleMetadata);
+    const moduleMetadataRepo = (isEmbeddedDb() ? event.queryRunner.manager : this.dataSource).getRepository(ModuleMetadata);
     const populatedModuleMetadata = await moduleMetadataRepo.findOne({
       where: { id: moduleMetadata.id },
     });
@@ -160,7 +161,7 @@ export class ScheduledJobSubscriber
       (job) => job.scheduleName === jobName
     );
     // Insert or update job in metadata
-    const jobDto: CreateScheduledJobDto = await this.scheduledJobRepo.toDto(populatedScheduleJob as ScheduledJob);
+    const jobDto: CreateScheduledJobDto = await this.scheduledJobRepo.toDto(populatedScheduleJob as ScheduledJob, isEmbeddedDb() ? entityManager : undefined);
     // Strip out bookkeeping/runtime fields before persisting to metadata JSON.
     const {
       moduleId,