@solidxai/core 0.1.11-beta.1 → 0.1.11-beta.12

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

@@ -151,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({

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,

package/src/subscribers/security-rule.subscriber.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs/promises'; // Use the Promise-based version of fs for as
 import { SOLID_CORE_MODULE_NAME } from 'src/constants';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
+import { isEmbeddedDb } from "src/helpers/environment.helper";
 import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
 import { SecurityRuleRepository } from 'src/repository/security-rule.repository';
 import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
@@ -40,7 +41,11 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
             return;
         }
 
-        const modelMetadataRepo = event.manager.getRepository(ModelMetadata);
+        // On embedded PGlite, use the transaction's connection to avoid a
+        // second pooled connection mid-transaction. On regular Postgres, use
+        // the default DataSource (original behaviour).
+        const mgr = isEmbeddedDb() ? event.manager : this.dataSource;
+        const modelMetadataRepo = mgr.getRepository(ModelMetadata);
         const populatedModelMetadata = await modelMetadataRepo.findOne({
             where: {
                 id: modelMetadata.id
@@ -67,12 +72,12 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
 
         if (metaData.securityRules) {
             const securityRuleIndex = metaData.securityRules?.findIndex((ruleFromFile: { name: string }) => ruleFromFile.name === securityRule.name);
-            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule, isEmbeddedDb() ? event.manager : undefined)
             metaData.securityRules[securityRuleIndex] = { ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) }
         }
         else {
             const securityRules = []
-            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule, isEmbeddedDb() ? event.manager : undefined)
             securityRules.push({ ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) })
             metaData.securityRules = securityRules
         }

package/dist/entities/legacy-common-with-id.entity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy-common-with-id.entity.d.ts","sourceRoot":"","sources":["../../src/entities/legacy-common-with-id.entity.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8B,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAEtG,8BACsB,iCAAkC,SAAQ,gCAAgC;IAI5F,EAAE,EAAE,MAAM,CAAA;CACb"}

package/dist/entities/legacy-common-with-id.entity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy-common-with-id.entity.js","sourceRoot":"","sources":["../../src/entities/legacy-common-with-id.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,yDAAoD;AACpD,qCAA4C;AAC5C,iEAAsG;AAG/F,IAAe,iCAAiC,GAAhD,MAAe,iCAAkC,SAAQ,uDAAgC;;;;CAK/F,CAAA;AALqB,8EAAiC;AAInD;IAHC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,iDAA0B,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACnF,IAAA,mBAAS,EAAC,WAAW,CAAC;;6DACb;4CAJQ,iCAAiC;IADtD,IAAA,2BAAO,GAAE;GACY,iCAAiC,CAKtD","sourcesContent":["import { Exclude, Expose } from \"class-transformer\";\nimport { Column, Generated } from \"typeorm\";\nimport { LEGACY_TABLE_FIELDS_PREFIX, LegacyCommonEntityWithExistingId } from \"./legacy-common.entity\";\n\n@Exclude()\nexport abstract class LegacyCommonEntityWithGeneratedId extends LegacyCommonEntityWithExistingId  {\n    @Expose()\n    @Column({ type: 'integer', name: `${LEGACY_TABLE_FIELDS_PREFIX}_id`, unique: true })\n    @Generated(\"increment\")\n    id: number\n}"]}

package/dist/entities/legacy-common.entity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy-common.entity.d.ts","sourceRoot":"","sources":["../../src/entities/legacy-common.entity.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,8BACsB,gCAAgC;IAOlD,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IAGvB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IAIvB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IAGvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAI9B,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IAIzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAI1B,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IAgBrC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAIzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B"}

package/dist/entities/legacy-common.entity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy-common.entity.js","sourceRoot":"","sources":["../../src/entities/legacy-common.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,yDAAoD;AACpD,qGAAgG;AAChG,qCAA8F;AAEjF,QAAA,0BAA0B,GAAG,IAAI,CAAC;AAGxC,IAAe,gCAAgC,GAA/C,MAAe,gCAAgC;;;;CAkDrD,CAAA;AAlDqB,4EAAgC;AAOlD;IADC,IAAA,0BAAgB,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,aAAa,EAAE,WAAW,EAAE,sDAAwB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;8BACnH,IAAI;mEAAQ;AAGvB;IADC,IAAA,0BAAgB,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,aAAa,EAAE,WAAW,EAAE,sDAAwB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;8BACnH,IAAI;mEAAQ;AAIvB;IAFC,IAAA,0BAAgB,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,aAAa,EAAE,WAAW,EAAE,sDAAwB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC7H,IAAA,eAAK,GAAE;8BACG,IAAI;mEAAQ;AAGvB;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,kBAAkB,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;wEAC5E;AAI9B;IAFC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,sDAAwB,EAAE,CAAC;8BACxH,IAAI;qEAAQ;AAIzB;IAFC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,kCAA0B,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;oEACpF;AAI1B;IAFC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,kCAA0B,2BAA2B,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;+EAClF;AAgBrC;IAFC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;mEACvD;AAIzB;IAFC,IAAA,0BAAM,GAAE;IACR,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,GAAG,kCAA0B,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;mEACvD;2CAjDP,gCAAgC;IADrD,IAAA,2BAAO,GAAE;GACY,gCAAgC,CAkDrD","sourcesContent":["import { Exclude, Expose } from \"class-transformer\";\nimport { LocalDateTimeTransformer } from \"src/transformers/typeorm/local-date-time-transformer\";\nimport { Column, CreateDateColumn, DeleteDateColumn, Index, UpdateDateColumn } from \"typeorm\";\n\nexport const LEGACY_TABLE_FIELDS_PREFIX = 'ss';\n\n@Exclude()\nexport abstract class LegacyCommonEntityWithExistingId {\n    // @Expose()\n    // @Column({ type: 'integer', name: `${LEGACY_TABLE_FIELDS_PREFIX}_id`, unique: true })\n    // @Generated(\"increment\")\n    // id: number\n\n    @CreateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_at`, transformer: LocalDateTimeTransformer, nullable: true })\n    createdAt: Date | null;\n\n    @UpdateDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_at`, transformer: LocalDateTimeTransformer, nullable: true })\n    updatedAt: Date | null;\n\n    @DeleteDateColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_at`, transformer: LocalDateTimeTransformer, nullable: true })\n    @Index()\n    deletedAt: Date | null;\n\n    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_deleted_tracker`, default: \"not-deleted\", nullable: true })\n    deletedTracker: string | null;\n\n    @Expose()\n    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_published_at`, default: null, nullable: true, transformer: LocalDateTimeTransformer })\n    publishedAt: Date | null;\n\n    @Expose()\n    @Column({ type: \"varchar\", name: `${LEGACY_TABLE_FIELDS_PREFIX}_locale_name`, default: null, nullable: true })\n    localeName: string | null;\n\n    @Expose()\n    @Column({ type: \"int\", name: `${LEGACY_TABLE_FIELDS_PREFIX}_default_entity_locale_id`, default: null, nullable: true })\n    defaultEntityLocaleId: number | null;\n\n    // @Expose()\n    // @Type( () => require('./user.entity').User?.default ?? require('./user.entity').User )\n    // @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })\n    // @JoinColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_by_id` })\n    // createdBy: User;\n\n    // @Expose()\n    // @Type( () => require('./user.entity').User?.default ?? require('./user.entity').User )\n    // @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })\n    // @JoinColumn({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_by_id` })\n    // updatedBy: User;    \n\n    @Expose()\n    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_created_by_id`, nullable: true })\n    createdBy: number | null;\n\n    @Expose()\n    @Column({ name: `${LEGACY_TABLE_FIELDS_PREFIX}_updated_by_id`, nullable: true })\n    updatedBy: number | null;\n}\n"]}