@solidxai/core 0.1.11-beta.9 → 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

@@ -4,7 +4,6 @@ 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';
@@ -89,10 +88,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
      */
     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 =>
+        const auditRelationFields = (await this.modelMetadataHelperService.loadFieldHierarchy(lowerFirst(event.metadata.name))).filter(field =>
             field.enableAuditTracking &&
             field.type === 'relation' &&
             field.relationType !== 'one-to-many'
@@ -110,7 +106,7 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         const relationBefore = event.entity?.[AUDIT_BEFORE_SNAPSHOT] ?? null;
 
-        const relationAfter = await mgr.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,
         });
@@ -155,11 +151,6 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
         if (batch.length === 0) return;
 
-        if (isEmbeddedDb()) {
-            setImmediate(() => void this.publishAuditBatch(batch));
-            return;
-        }
-
         await this.publishAuditBatch(batch);
     }
 

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

@@ -1,7 +1,6 @@
 import { camelCase } from 'lodash';
 import { forwardRef, Inject, Injectable, InternalServerErrorException, Logger, Scope } from "@nestjs/common";
 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";
@@ -17,13 +16,6 @@ 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(
         private readonly solidRegistry: SolidRegistry,
         @Inject(forwardRef(() => PublisherFactory))
@@ -68,18 +60,8 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
 
     //FIXME: Need to add support for beforeRemove, beforeSoftRemove, afterSoftRemove, beforeRecover, afterRecover
 
-    // --------- 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>,
+        _event: InsertEvent<any> | UpdateEvent<any> | RemoveEvent<any>,
         entity: any,
         currentOperation: ComputedFieldTriggerOperation,
         modelName: string,
@@ -94,44 +76,11 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         );
         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,
-                );
-            }
-        }
-    }
-
-    // --------- 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);
+        for (const computedField of computedFieldsTobeEvaluated) {
+            this.enqueueComputedFieldEvaluationJob(
+                this.attachContext(computedField, eventContext),
+                entity,
+            );
         }
     }
 
@@ -199,10 +148,8 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
     }
 
     private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any) {
-        const { manager: _manager, ...serializableEventContext } = computedField.eventContext ?? {};
         const payload = {
             ...computedField,
-            eventContext: serializableEventContext,
             databaseEntity,
         };
         this.publisherFactory.publish({ payload }, 'ComputedFieldEvaluationPublisher');
@@ -224,10 +171,6 @@ 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,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

@@ -4,7 +4,6 @@ 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 {
@@ -84,7 +83,7 @@ export class ScheduledJobSubscriber
       return;
     }
 
-    const moduleMetadataRepo = (isEmbeddedDb() ? event.queryRunner.manager : this.dataSource).getRepository(ModuleMetadata);
+    const moduleMetadataRepo = this.dataSource.getRepository(ModuleMetadata);
     const populatedModuleMetadata = await moduleMetadataRepo.findOne({
       where: { id: moduleMetadata.id },
     });
@@ -161,7 +160,7 @@ export class ScheduledJobSubscriber
       (job) => job.scheduleName === jobName
     );
     // Insert or update job in metadata
-    const jobDto: CreateScheduledJobDto = await this.scheduledJobRepo.toDto(populatedScheduleJob as ScheduledJob, isEmbeddedDb() ? entityManager : undefined);
+    const jobDto: CreateScheduledJobDto = await this.scheduledJobRepo.toDto(populatedScheduleJob as ScheduledJob);
     // Strip out bookkeeping/runtime fields before persisting to metadata JSON.
     const {
       moduleId,

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

@@ -4,7 +4,6 @@ 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";
@@ -41,11 +40,7 @@ export class SecurityRuleSubscriber implements EntitySubscriberInterface<Securit
             return;
         }
 
-        // 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 modelMetadataRepo = this.dataSource.getRepository(ModelMetadata);
         const populatedModelMetadata = await modelMetadataRepo.findOne({
             where: {
                 id: modelMetadata.id
@@ -72,12 +67,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, isEmbeddedDb() ? event.manager : undefined)
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
             metaData.securityRules[securityRuleIndex] = { ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) }
         }
         else {
             const securityRules = []
-            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule, isEmbeddedDb() ? event.manager : undefined)
+            const { id, roleId, modelMetadataId, ...requiredDto } = await this.securityRuleRepo.toDto(securityRule)
             securityRules.push({ ...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig) })
             metaData.securityRules = securityRules
         }

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
-      }
-    },
-  };
-}