@solidxai/core 0.1.11-beta.8 → 0.1.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/subscribers/audit.subscriber.ts

@@ -106,7 +106,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         const relationBefore = event.entity?.[AUDIT_BEFORE_SNAPSHOT] ?? null;
 
-        const relationAfter = await event.manager.getRepository(event.metadata.target as any).findOne({
+        const relationAfter = await this.dataSource.getRepository(event.metadata.target as any).findOne({
             where: { id: entityId } as any,
             relations: relations as any,
         });
@@ -151,11 +151,6 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         if (batch.length === 0) return;
 
-        if (this.shouldDeferAuditPublish()) {
-            setImmediate(() => void this.publishAuditBatch(batch));
-            return;
-        }
-
         await this.publishAuditBatch(batch);
     }
 
@@ -164,12 +159,6 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         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.

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

@@ -1,7 +1,5 @@
 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 { ComputedFieldMetadata, SolidRegistry, TypeOrmEventContext } from "src/helpers/solid-registry";
 import { IEntityPreComputeFieldProvider } from "src/interfaces";
@@ -14,19 +12,15 @@ 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;
+
     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 +37,54 @@ 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;
-        }
+    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
+        if (computedFieldsTobeEvaluated.length === 0) return;
+
         for (const computedField of computedFieldsTobeEvaluated) {
-            await this.evaluateComputedField(this.attachContext(computedField, eventContext), entity, currentOperation);
+            this.enqueueComputedFieldEvaluationJob(
+                this.attachContext(computedField, eventContext),
+                entity,
+            );
         }
     }
 
-    private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext) {
+    private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext): Promise<void> {
         if (!entity) {
             return;
         }
@@ -92,9 +93,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,17 +147,12 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         }
     }
 
-    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any, eventContext?: any) {
-        const { manager: _manager, ...serializableEventContext } = computedField.eventContext ?? {};
+    private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any) {
         const payload = {
             ...computedField,
-            eventContext: serializableEventContext,
             databaseEntity,
         };
-        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 {
@@ -176,7 +171,6 @@ 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,9 +38,6 @@ 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,9 +21,6 @@ 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

@@ -83,7 +83,7 @@ export class ScheduledJobSubscriber
       return;
     }
 
-    const moduleMetadataRepo = event.queryRunner.manager.getRepository(ModuleMetadata);
+    const moduleMetadataRepo = this.dataSource.getRepository(ModuleMetadata);
     const populatedModuleMetadata = await moduleMetadataRepo.findOne({
       where: { id: moduleMetadata.id },
     });

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

@@ -40,7 +40,7 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
             return;
         }
 
-        const modelMetadataRepo = event.manager.getRepository(ModelMetadata);
+        const modelMetadataRepo = this.dataSource.getRepository(ModelMetadata);
         const populatedModelMetadata = await modelMetadataRepo.findOne({
             where: {
                 id: modelMetadata.id

package/dist/helpers/nodemon-heartbeat.d.ts

@@ -1,5 +0,0 @@
-export interface NodemonHeartbeatHandle {
-    stop: () => void;
-}
-export declare function startNodemonHeartbeat(srcDir: string): NodemonHeartbeatHandle;
-//# sourceMappingURL=nodemon-heartbeat.d.ts.map

package/dist/helpers/nodemon-heartbeat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodemon-heartbeat.d.ts","sourceRoot":"","sources":["../../src/helpers/nodemon-heartbeat.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AASD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CA8B5E"}

package/dist/helpers/nodemon-heartbeat.js

@@ -1,67 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startNodemonHeartbeat = startNodemonHeartbeat;
-const fsSync = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const HEARTBEAT_FILENAME = 'solidx-nodemon-heartbeat.json';
-const HEARTBEAT_INTERVAL_MS = 1500;
-function startNodemonHeartbeat(srcDir) {
-    const filePath = path.join(srcDir, HEARTBEAT_FILENAME);
-    let stopped = false;
-    const touch = () => {
-        try {
-            fsSync.writeFileSync(filePath, String(Date.now()));
-        }
-        catch {
-        }
-    };
-    touch();
-    const timer = setInterval(touch, HEARTBEAT_INTERVAL_MS);
-    return {
-        stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            clearInterval(timer);
-            try {
-                fsSync.unlinkSync(filePath);
-            }
-            catch {
-            }
-        },
-    };
-}
-//# sourceMappingURL=nodemon-heartbeat.js.map

package/dist/helpers/nodemon-heartbeat.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodemon-heartbeat.js","sourceRoot":"","sources":["../../src/helpers/nodemon-heartbeat.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,sDA8BC;AA1DD,2CAA6B;AAC7B,2CAA6B;AAa7B,MAAM,kBAAkB,GAAG,+BAA+B,CAAC;AAC3D,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAanC,SAAgB,qBAAqB,CAAC,MAAc;IAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACvD,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,MAAM,KAAK,GAAG,GAAG,EAAE;QACjB,IAAI,CAAC;YACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrD,CAAC;QAAC,MAAM,CAAC;QAGT,CAAC;IACH,CAAC,CAAC;IAGF,KAAK,EAAE,CAAC;IAER,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,EAAE,qBAAqB,CAAC,CAAC;IAExD,OAAO;QACL,IAAI;YACF,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,aAAa,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC;gBACH,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YAC9B,CAAC;YAAC,MAAM,CAAC;YAET,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import * as fsSync from 'fs';\nimport * as path from 'path';\n\n/**\n * The heartbeat file is placed inside the nodemon-watched src/ directory so\n * that touching it resets nodemon's restart delay. This prevents nodemon from\n * restarting the API server while in-process code generation is writing files\n * (which is especially important for embedded PGlite projects where the\n * generate-code endpoint runs schematics in-process).\n *\n * The file uses a .json extension because nodemon is configured to watch\n * ts,json files. It is placed at the src/ root (not inside any metadata\n * directory) so it is not caught by the metadata JSON ignore rule.\n */\nconst HEARTBEAT_FILENAME = 'solidx-nodemon-heartbeat.json';\nconst HEARTBEAT_INTERVAL_MS = 1500;\n\nexport interface NodemonHeartbeatHandle {\n  stop: () => void;\n}\n\n/**\n * Starts a heartbeat that touches a file in the nodemon-watched directory\n * every ~1.5 s. Call `stop()` after the response has been flushed to allow\n * nodemon to restart.\n *\n * @param srcDir Absolute path to the `src/` directory nodemon watches.\n */\nexport function startNodemonHeartbeat(srcDir: string): NodemonHeartbeatHandle {\n  const filePath = path.join(srcDir, HEARTBEAT_FILENAME);\n  let stopped = false;\n\n  const touch = () => {\n    try {\n      fsSync.writeFileSync(filePath, String(Date.now()));\n    } catch {\n      // best-effort — if the file can't be written, nodemon will simply\n      // restart as usual, which is the safe fallback.\n    }\n  };\n\n  // Write immediately so the delay resets before any schematic output lands.\n  touch();\n\n  const timer = setInterval(touch, HEARTBEAT_INTERVAL_MS);\n\n  return {\n    stop() {\n      if (stopped) return;\n      stopped = true;\n      clearInterval(timer);\n      try {\n        fsSync.unlinkSync(filePath);\n      } catch {\n        // file may not exist — ignore\n      }\n    },\n  };\n}\n"]}

package/src/helpers/nodemon-heartbeat.ts

@@ -1,59 +0,0 @@
-import * as fsSync from 'fs';
-import * as path from 'path';
-
-/**
- * The heartbeat file is placed inside the nodemon-watched src/ directory so
- * that touching it resets nodemon's restart delay. This prevents nodemon from
- * restarting the API server while in-process code generation is writing files
- * (which is especially important for embedded PGlite projects where the
- * generate-code endpoint runs schematics in-process).
- *
- * The file uses a .json extension because nodemon is configured to watch
- * ts,json files. It is placed at the src/ root (not inside any metadata
- * directory) so it is not caught by the metadata JSON ignore rule.
- */
-const HEARTBEAT_FILENAME = 'solidx-nodemon-heartbeat.json';
-const HEARTBEAT_INTERVAL_MS = 1500;
-
-export interface NodemonHeartbeatHandle {
-  stop: () => void;
-}
-
-/**
- * Starts a heartbeat that touches a file in the nodemon-watched directory
- * every ~1.5 s. Call `stop()` after the response has been flushed to allow
- * nodemon to restart.
- *
- * @param srcDir Absolute path to the `src/` directory nodemon watches.
- */
-export function startNodemonHeartbeat(srcDir: string): NodemonHeartbeatHandle {
-  const filePath = path.join(srcDir, HEARTBEAT_FILENAME);
-  let stopped = false;
-
-  const touch = () => {
-    try {
-      fsSync.writeFileSync(filePath, String(Date.now()));
-    } catch {
-      // best-effort — if the file can't be written, nodemon will simply
-      // restart as usual, which is the safe fallback.
-    }
-  };
-
-  // Write immediately so the delay resets before any schematic output lands.
-  touch();
-
-  const timer = setInterval(touch, HEARTBEAT_INTERVAL_MS);
-
-  return {
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      clearInterval(timer);
-      try {
-        fsSync.unlinkSync(filePath);
-      } catch {
-        // file may not exist — ignore
-      }
-    },
-  };
-}