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

package/src/dtos/datasource-introspection-mapping.dto.ts

@@ -22,6 +22,10 @@ export class DatasourceIntrospectionMappingColumnDto {
     @IsString()
     fieldName: string;
 
+    @ApiProperty()
+    @IsString()
+    displayName: string;
+
     @ApiProperty()
     @IsString()
     dataType: string;
@@ -91,6 +95,11 @@ export class DatasourceIntrospectionMappingColumnDto {
     @ApiProperty()
     @IsBoolean()
     isPrimaryKey: boolean;
+
+    @ApiProperty({ required: false, type: "object", additionalProperties: true })
+    @IsOptional()
+    @IsObject()
+    fieldConfig?: Record<string, any>;
 }
 
 export class DatasourceIntrospectionMappingDto {
@@ -180,3 +189,9 @@ export class DatasourceIntrospectionMappingDto {
     @IsObject()
     reviewedModel?: Record<string, any>;
 }
+
+export class DatasourceIntrospectionRunMigrationDto {
+    @ApiProperty()
+    @IsString()
+    datasource: string;
+}

package/src/entities/{legacy-common-with-id.entity.ts → legacy-common-with-generated-id.entity.ts}

@@ -1,6 +1,6 @@
 import { Exclude, Expose } from "class-transformer";
 import { Column, Generated } from "typeorm";
-import { LEGACY_TABLE_FIELDS_PREFIX, LegacyCommonEntityWithExistingId } from "./legacy-common.entity";
+import { LEGACY_TABLE_FIELDS_PREFIX, LegacyCommonEntityWithExistingId } from "./legacy-common.entity-with-existing-id.entity";
 
 @Exclude()
 export abstract class LegacyCommonEntityWithGeneratedId extends LegacyCommonEntityWithExistingId  {

package/src/helpers/command.service.ts

@@ -10,6 +10,10 @@ export type CommandWithArgs = {
 @Injectable()
 export class CommandService {
   private readonly logger = new Logger(CommandService.name);
+  private readonly ansiEscapePattern =
+    // Covers standard ANSI CSI, OSC, and related terminal escape sequences.
+    // eslint-disable-next-line no-control-regex
+    /[\u001B\u009B][[\]()#;?]*(?:(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><~]|(?:][^\u0007]*(?:\u0007|\u001B\\)))/g;
 
   /**
    * Escape an argument for Windows CMD shell
@@ -51,11 +55,11 @@ export class CommandService {
       let stderr = '';
 
       child.stdout.on('data', (data) => {
-        stdout += data.toString();
+        stdout += this.stripAnsi(data.toString());
       });
 
       child.stderr.on('data', (data) => {
-        stderr += data.toString();
+        stderr += this.stripAnsi(data.toString());
       });
 
       child.on('error', (error) => {
@@ -73,4 +77,8 @@ export class CommandService {
       });
     });
   }
+
+  private stripAnsi(value: string): string {
+    return value.replace(this.ansiEscapePattern, '');
+  }
 }

package/src/helpers/environment.helper.ts

@@ -13,4 +13,15 @@ export function isRedisConfigured(configService: ConfigService): boolean {
     const host = configService.get<string>('REDIS_HOST');
     const port = configService.get<string>('REDIS_PORT');
     return host && port && isNumber(parseInt(port));
+}
+
+/**
+ * Returns true when the project is configured to use an embedded PGlite
+ * database with a single-connection pool. Several TypeORM subscriber and
+ * code-generation workarounds are only necessary (and only applied) under
+ * this constraint; on a regular multi-connection Postgres pool the original
+ * behaviour is preserved.
+ */
+export function isEmbeddedDb(): boolean {
+    return process.env.DEFAULT_DATABASE_DRIVER === 'pglite';
 }

package/src/helpers/field-crud-managers/IntFieldCrudManager.ts

@@ -15,7 +15,10 @@ export class IntFieldCrudManager implements FieldCrudManager {
 
     validate(createDto: any): ValidationError[] {
         const fieldValue: any = createDto[this.options.fieldName];
-        return this.applyValidations(fieldValue);
+        if (typeof fieldValue === 'string' && /^\d+$/.test(fieldValue.trim())) {
+            createDto[this.options.fieldName] = Number.parseInt(fieldValue, 10);
+        }
+        return this.applyValidations(createDto[this.options.fieldName]);
     }
 
     private applyValidations(fieldValue: any): ValidationError[] {

package/src/helpers/model-metadata-helper.service.ts

@@ -2,10 +2,12 @@
 
 import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
 import { _ } from "lodash";
-import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
+import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity-with-existing-id.entity";
 import { LegacyTableType } from "src/enums/legacy-table-type.enum";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
 import { SolidRegistry } from "./solid-registry";
+import { EntityManager } from "typeorm";
 
 @Injectable()
 export class ModelMetadataHelperService {
@@ -143,8 +145,11 @@ export class ModelMetadataHelperService {
         return systemFieldsMetadata;
     }
 
-    async loadFieldHierarchy(modelName: any) {
-        const model = await this.modelMetadataRepo.findOne({
+    async loadFieldHierarchy(modelName: any, manager?: EntityManager) {
+        const repo = manager
+            ? manager.getRepository(ModelMetadata)
+            : this.modelMetadataRepo;
+        const model = await repo.findOne({
             where: {
                 singularName: modelName,
             },

package/src/helpers/nodemon-heartbeat.ts

@@ -0,0 +1,59 @@
+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
+      }
+    },
+  };
+}

package/src/helpers/solid-registry.ts

@@ -8,7 +8,7 @@ import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
 import { IDashboardWidgetDataProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
-import { ObjectLiteral } from 'typeorm';
+import { EntityManager, ObjectLiteral } from 'typeorm';
 
 type ControllerMetadata = {
   name: string;
@@ -49,6 +49,12 @@ export interface TypeOrmEventContext {
   metadataName?: string;
   updatedColumns?: string[];
   updatedRelations?: string[];
+  // Transaction-bound EntityManager from the originating TypeORM event. Providers that
+  // need to query the DB during a pre-compute hook must use this (not an injected
+  // DataSource/EntityManager) so the query runs on the active transaction's connection.
+  // On single-threaded embedded engines (PGlite), a second connection mid-transaction
+  // can deadlock.
+  manager?: EntityManager;
 }
 
 export interface ComputedFieldMetadata<TContext = any> {

package/src/helpers/typeorm-db-helper.ts

@@ -45,6 +45,21 @@ const solidCoreDbType: DatasourceType =
         ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
         : DatasourceType.postgres;
 
+// Must use ANSI CAST() syntax — not Postgres-specific `::text` — because TypeORM's
+// replacePropertyNamesForTheWholeQuery regex treats ':' as part of the property name,
+// so `alias.col::text` is parsed as property `col::text` (no match → no column substitution).
+export function buildCastToText(driver: string, colExpr: string): string {
+    switch (driver) {
+        case DatasourceType.mssql:
+            return `CAST(${colExpr} AS NVARCHAR(MAX))`;
+        case DatasourceType.mysql:
+        case DatasourceType.mariadb:
+            return `CAST(${colExpr} AS CHAR)`;
+        default:
+            return `CAST(${colExpr} AS TEXT)`;
+    }
+}
+
 export function getColumnType(solidType: string): ColumnOptions {
     switch (solidType) {
         case "longText":

package/src/index.ts

@@ -119,8 +119,8 @@ export * from './dtos/update-dashboard-user-layout.dto'
 
 export * from './entities/action-metadata.entity'
 export * from './entities/common.entity'
-export * from './entities/legacy-common.entity'
-export * from './entities/legacy-common-with-id.entity'
+export * from './entities/legacy-common.entity-with-existing-id.entity'
+export * from './entities/legacy-common-with-generated-id.entity'
 export * from './entities/email-attachment.entity'
 export * from './entities/email-template.entity'
 export * from './entities/field-metadata.entity'
@@ -171,6 +171,7 @@ export * from './guards/permissions.guard'
 export * from './guards/roles.guard'
 
 export * from './helpers/command.service'
+export * from './helpers/nodemon-heartbeat'
 export * from './helpers/module.helper'
 export * from './helpers/schematic.service'
 export * from './helpers/solid-registry'

package/src/interfaces/datasource-introspection-provider.interface.ts

@@ -11,6 +11,7 @@ export type DatasourceIntrospectionColumn = {
     columnName: string;
     dataType: string;
     isAutoGenerated: boolean;
+    isPrimaryKey: boolean;
     isNullable: boolean;
     defaultValue: string | null;
     characterMaximumLength: number | null;

package/src/interfaces.ts

@@ -89,6 +89,7 @@ export interface SettingDefinition<T = any> {
   encrypted?: boolean;
   label?: string;
   description?: string;
+  helpText?: string;
   placeholder?: string;
   group?: string;
   sortOrder?: number;

package/src/repository/scheduled-job.repository.ts

@@ -3,7 +3,7 @@ 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 { RequestContextService } from "src/services/request-context.service";
-import { DataSource } from "typeorm";
+import { DataSource, EntityManager } from "typeorm";
 import { SecurityRuleRepository } from "./security-rule.repository";
 import { SolidBaseRepository } from "./solid-base.repository";
 
@@ -34,21 +34,92 @@ export class ScheduledJobRepository extends SolidBaseRepository<ScheduledJob> {
         super(ScheduledJob, dataSource, requestContextService, securityRuleRepository);
     }
 
+  private normalizeComparableValue(value: any): any {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+
+    if (typeof value === "string") {
+      const trimmedValue = value.trim();
+      if (
+        (trimmedValue.startsWith("{") && trimmedValue.endsWith("}")) ||
+        (trimmedValue.startsWith("[") && trimmedValue.endsWith("]"))
+      ) {
+        try {
+          return this.normalizeComparableValue(JSON.parse(trimmedValue));
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeComparableValue(item));
+    }
+
+    if (value && typeof value === "object") {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = this.normalizeComparableValue(value[key]);
+          return result;
+        }, {} as Record<string, any>);
+    }
+
+    return value;
+  }
+
+  private areValuesDifferent(currentValue: any, nextValue: any): boolean {
+    const normalizedCurrentValue = this.normalizeComparableValue(currentValue);
+    const normalizedNextValue = this.normalizeComparableValue(nextValue);
+
+    if (
+      (normalizedCurrentValue && typeof normalizedCurrentValue === "object") ||
+      (normalizedNextValue && typeof normalizedNextValue === "object")
+    ) {
+      return JSON.stringify(normalizedCurrentValue ?? null) !== JSON.stringify(normalizedNextValue ?? null);
+    }
+
+    return normalizedCurrentValue !== normalizedNextValue;
+  }
+
+  private hasChanges(existing: ScheduledJob, dto: CreateScheduledJobDto, moduleEntity: ModuleMetadata): boolean {
+    return existing.scheduleName !== dto.scheduleName
+      || existing.isActive !== dto.isActive
+      || this.areValuesDifferent(existing.frequency, dto.frequency)
+      || this.areValuesDifferent(existing.startTime, dto.startTime)
+      || this.areValuesDifferent(existing.endTime, dto.endTime)
+      || this.areValuesDifferent(existing.startDate, dto.startDate)
+      || this.areValuesDifferent(existing.endDate, dto.endDate)
+      || this.areValuesDifferent(existing.dayOfMonth, dto.dayOfMonth)
+      || this.areValuesDifferent(existing.dayOfWeek, dto.dayOfWeek)
+      || this.areValuesDifferent(existing.job, dto.job)
+      || this.areValuesDifferent(existing.cronExpression, dto.cronExpression)
+      || existing.module?.id !== moduleEntity.id;
+  }
+
   /**
    * Converts an entity to a plain DTO object.
+   * When manager is provided (e.g. from a TypeORM subscriber event), the
+   * fallback relation load uses it so the query runs on the active
+   * transaction's connection instead of the default DataSource pool.
    */
-  async toDto(scheduledJob: ScheduledJob): Promise<CreateScheduledJobDto> {
+  async toDto(scheduledJob: ScheduledJob, manager?: EntityManager): Promise<CreateScheduledJobDto> {
     let populatedScheduledJob: ScheduledJob = scheduledJob;
     // If the scheduled job does not have the module relation loaded, load it
     if (!scheduledJob.module) {
-        populatedScheduledJob = await this.findOne({
+        const repo = manager
+            ? manager.getRepository(ScheduledJob)
+            : this;
+        populatedScheduledJob = await repo.findOne({
             where: {
                 id: scheduledJob.id,
             },
             relations: {
                 module: true,
             },
-        });
+        }) ?? scheduledJob;
     }
 
     if (!populatedScheduledJob.module) {
@@ -91,9 +162,17 @@ export class ScheduledJobRepository extends SolidBaseRepository<ScheduledJob> {
     };
     const existing = await this.findOne({
       where: { scheduleName: dto.scheduleName },
+      relations: {
+        module: true,
+      },
     });
 
     if (existing) {
+      if (!this.hasChanges(existing, dto, moduleEntity)) {
+        this.logger.debug(`Skipping scheduled job upsert for ${dto.scheduleName}; no changes detected.`);
+        return existing;
+      }
+
       const merged = this.merge(existing, jobData);
       this.logger.debug(`Updating scheduled job: ${dto.scheduleName}`);
       return this.save(merged);

package/src/repository/security-rule.repository.ts

@@ -9,7 +9,7 @@ import { SecurityRule } from 'src/entities/security-rule.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { CrudHelperService } from 'src/services/crud-helper.service';
-import { Brackets, DataSource, SelectQueryBuilder } from 'typeorm';
+import { Brackets, DataSource, EntityManager, SelectQueryBuilder } from 'typeorm';
 import { SolidBaseRepository } from './solid-base.repository';
 
 @Injectable()
@@ -84,12 +84,18 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
         return configString.replace('$activeUserId', activeUser.sub.toString());
     }
 
-    async toDto(securityRule: SecurityRule): Promise<UpdateSecurityRuleDto> {
+    async toDto(securityRule: SecurityRule, manager?: EntityManager): Promise<UpdateSecurityRuleDto> {
         // load the role and model relations for the security rule
         let populatedSecurityRule: SecurityRule = securityRule;
         // If the security rule does not have the role and model relations loaded, load them
         if (!securityRule.role || !securityRule.modelMetadata) {
-            populatedSecurityRule = await this.findOne({
+            // When a manager is provided (e.g. from a TypeORM subscriber event),
+            // use it so the query runs on the active transaction's connection
+            // instead of trying to acquire a second connection from the pool.
+            const repo = manager
+                ? manager.getRepository(SecurityRule)
+                : this;
+            populatedSecurityRule = await repo.findOne({
                 where: {
                     id: securityRule.id,
                 },
@@ -97,7 +103,7 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
                     role: true,
                     modelMetadata: true,
                 },
-            });
+            }) ?? securityRule;
         }
 
         return {