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

package/src/subscribers/audit.subscriber.ts

@@ -84,24 +84,44 @@ 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'))
-        );
-
-        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 (batch.length === 0) return;
+
+        if (this.shouldDeferAuditPublish()) {
+            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 shouldDeferAuditPublish(): boolean {
+        const driver = (process.env.DEFAULT_DATABASE_DRIVER ?? '').toLowerCase();
+        const poolMax = Number(process.env.DEFAULT_DATABASE_POOL_MAX ?? 20);
+        return driver === 'pglite' && Number.isFinite(poolMax) && poolMax <= 1;
+    }
+
+    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

@@ -175,6 +175,7 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         const base: TypeOrmEventContext = {
             metadataName: event.metadata?.name,
             eventType: eventType,
+            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) {