@solidxai/core 0.1.11-beta.1 → 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";
 
@@ -101,19 +101,25 @@ export class ScheduledJobRepository extends SolidBaseRepository<ScheduledJob> {
 
   /**
    * 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) {

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 {

package/src/seeders/module-metadata-seeder.service.ts

@@ -1,5 +1,6 @@
 import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -20,6 +21,7 @@ import { CreateModuleMetadataDto } from '../dtos/create-module-metadata.dto';
 import { getDynamicModuleNamesBasedOnMetadata } from '../helpers/module.helper';
 import { SolidRegistry } from '../helpers/solid-registry';
 import { ActionMetadataService } from '../services/action-metadata.service';
+import { ApiKeyService } from '../services/api-key.service';
 import { FieldMetadataService } from '../services/field-metadata.service';
 import { MediaStorageProviderMetadataService } from '../services/media-storage-provider-metadata.service';
 import { ModelMetadataService } from '../services/model-metadata.service';
@@ -33,18 +35,22 @@ import { ActionMetadata } from '../entities/action-metadata.entity';
 import { MenuItemMetadata } from '../entities/menu-item-metadata.entity';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 import { RoleMetadata } from '../entities/role-metadata.entity';
+import { User } from '../entities/user.entity';
 import { MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL } from '../dtos/create-menu-item-metadata.dto';
 import { DEFAULT_SA_PASSWORD } from '../dtos/create-user.dto';
 import { SignUpDto } from '../dtos/sign-up.dto';
 import { ADMIN_ROLE_NAME, CreateRoleMetadataDto } from 'src/dtos/create-role-metadata.dto';
 import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
 import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
+import { CreateLocaleDto } from 'src/dtos/create-locale.dto';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
 import { SavedFiltersRepository } from 'src/repository/saved-filters.repository';
 import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
 import { SettingRepository } from 'src/repository/setting.repository';
+import { UserApiKeyRepository } from 'src/repository/user-api-key.repository';
 import { CreateModelSequenceDto } from 'src/dtos/create-model-sequence.dto';
 import { ModelSequenceRepository } from 'src/repository/model-sequence.repository';
+import { LocaleRepository } from 'src/repository/locale.repository';
 import { ModelSequence } from 'src/entities/model-sequence.entity';
 import { SavedFilters } from 'src/entities/saved-filters.entity';
 import { ScheduledJob } from 'src/entities/scheduled-job.entity';
@@ -97,11 +103,13 @@ export class ModuleMetadataSeederService {
         private readonly roleService: RoleMetadataService,
         private readonly userService: UserService,
         private readonly authenticationService: AuthenticationService,
+        private readonly apiKeyService: ApiKeyService,
         private readonly solidActionService: ActionMetadataService,
         private readonly solidViewService: ViewMetadataService,
         private readonly emailTemplateService: EmailTemplateService,
         private readonly smsTemplateService: SmsTemplateService,
         private readonly listOfValuesService: ListOfValuesService,
+        private readonly userApiKeyRepository: UserApiKeyRepository,
         // @InjectRepository(PermissionMetadata)
         // private readonly permissionRepo: Repository<PermissionMetadata>,
         private readonly permissionRepo: PermissionMetadataRepository,
@@ -116,6 +124,7 @@ export class ModuleMetadataSeederService {
         readonly savedFiltersRepo: SavedFiltersRepository,
         readonly dataSource: DataSource,
         readonly modelSequenceRepo: ModelSequenceRepository,
+        readonly localeRepo: LocaleRepository,
     ) { }
 
     async seed(conf?: any) {
@@ -194,6 +203,11 @@ export class ModuleMetadataSeederService {
                         const moduleModelFieldCounts = await this.timeOperation('seed-module-model-fields', () => this.seedModuleModelFields(moduleMetadata), { moduleName: moduleMetadata.name, component: 'module-model-fields' });
                         console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
 
+                currentStep = 'seedLocales';
+                this.logger.log(`Seeding Locales`);
+                const localeCounts = await this.seedLocales(overallMetadata);
+                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Locales', localeCounts)}`);
+
                         currentStep = 'seedPermissions';
                         this.logger.log(`Seeding Permissions`);
                         const permissionCounts = await this.timeOperation('seed-permissions', () => this.seedPermissions(overallMetadata), { moduleName: moduleMetadata.name, component: 'permissions' });
@@ -466,6 +480,22 @@ export class ModuleMetadataSeederService {
         return { pruned, upserted: listOfValues.length };
     }
 
+    private async seedLocales(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
+        this.logger.debug(`[Start] Processing locales`);
+        const locales = this.getSeedArray<CreateLocaleDto>(overallMetadata?.locales);
+        const existingLocales = await this.localeRepo.find();
+
+        if (existingLocales.length > 0) {
+            this.solidRegistry.registerlocales(existingLocales);
+            this.logger.debug(`[End] Skipping locale seed because locales already exist`);
+            return { pruned: 0, upserted: 0 };
+        }
+
+        await this.handleSeedLocales(locales);
+        this.logger.debug(`[End] Processing locales`);
+        return { pruned: 0, upserted: locales.length };
+    }
+
     private async setupDefaultRolesWithPermissions() {
         this.logger.debug(`About to add all permissions to the Admin role`);
         await this.timeOperation('role-add-all-permissions', () => this.roleService.addAllPermissionsToRole(ADMIN_ROLE_NAME), {
@@ -592,11 +622,15 @@ export class ModuleMetadataSeederService {
     // OK
     private async seedRoles(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         const roles = this.getSeedArray<CreateRoleMetadataDto>(overallMetadata?.roles);
-        // While creating roles we are only passing the role name to be used. 
+        // Preserve module linkage metadata so RoleMetadata.module is populated from the defining module.
         await this.timeOperation('roles-create-if-not-exists', () => this.roleService.createRolesIfNotExists(
             roles
                 .filter((role) => role?.name)
-                .map((role) => ({ name: role.name } as any)),
+                .map((role) => ({
+                    name: role.name,
+                    moduleId: role.moduleId,
+                    moduleUserKey: role.moduleUserKey ?? overallMetadata?.moduleMetadata?.name,
+                } as CreateRoleMetadataDto)),
         ), {
             moduleName: overallMetadata?.moduleMetadata?.name,
             component: 'roles',
@@ -1336,6 +1370,7 @@ export class ModuleMetadataSeederService {
 
         for (let l = 0; l < users.length; l++) {
             const user: SignUpDto = users[l];
+            const isSystemAdminUser = user.username === 'sa';
             let exisitingUser = await this.timeOperation('user-find-by-username', () => this.userService.findOneByUsername(user.username), {
                 component: 'users',
                 serviceCall: 'userService.findOneByUsername',
@@ -1345,14 +1380,32 @@ export class ModuleMetadataSeederService {
                 if (user.username === 'sa') {
                     user.password = DEFAULT_SA_PASSWORD;
                 }
+                if (isSystemAdminUser) {
+                    (user as SignUpDto & { isAllowedToGenerateApiKeys?: boolean }).isAllowedToGenerateApiKeys = true;
+                }
 
                 exisitingUser = await this.timeOperation('user-sign-up', () => this.authenticationService.signUp(user), {
                     component: 'users',
                     serviceCall: 'authenticationService.signUp',
                     details: `username=${user.username}`,
                 });
+                if (isSystemAdminUser) {
+                    await this.timeOperation('seed-sa-api-key', async () => {
+                        const generatedApiKey = await this.apiKeyService.generate(exisitingUser.id, {
+                            name: 'Default SA API Key',
+                        });
+                        await this.writeSolidxAdminApiKeyConfig(generatedApiKey);
+                    }, {
+                        component: 'users',
+                        serviceCall: 'apiKeyService.generate',
+                        details: `username=${user.username}`,
+                    });
+                }
                 this.logger.log(`Newly created user ${user.username}`);
             }
+            if (isSystemAdminUser) {
+                await this.ensureSystemAdminApiKey(exisitingUser);
+            }
             //FIXME: Create the user roles assignment logic here.
             // now add Roles to user.
             // for (let m = 0; m < roles.length; m++) {
@@ -1362,6 +1415,101 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private async ensureSystemAdminApiKey(existingUser: { id: number; username: string; isAllowedToGenerateApiKeys?: boolean }) {
+        if (!existingUser?.id) {
+            return;
+        }
+
+        if (!existingUser.isAllowedToGenerateApiKeys) {
+            await this.timeOperation('enable-sa-api-key-generation', () => this.userApiKeyRepository.manager.update(User, { id: existingUser.id }, {
+                isAllowedToGenerateApiKeys: true,
+            }), {
+                component: 'users',
+                serviceCall: 'userRepository.update',
+                details: `username=${existingUser.username}`,
+            });
+            existingUser.isAllowedToGenerateApiKeys = true;
+        }
+
+        const existingDefaultKey = await this.timeOperation('find-sa-default-api-key', () => this.userApiKeyRepository.findOne({
+            where: {
+                user: { id: existingUser.id },
+                name: 'Default SA API Key',
+            },
+            relations: {
+                user: true,
+            },
+        }), {
+            component: 'users',
+            serviceCall: 'userApiKeyRepository.findOne',
+            details: `username=${existingUser.username}`,
+        });
+
+        if (existingDefaultKey) {
+            return;
+        }
+
+        await this.timeOperation('seed-sa-api-key', async () => {
+            const generatedApiKey = await this.apiKeyService.generate(existingUser.id, {
+                name: 'Default SA API Key',
+            });
+            await this.writeSolidxAdminApiKeyConfig(generatedApiKey);
+        }, {
+            component: 'users',
+            serviceCall: 'apiKeyService.generate',
+            details: `username=${existingUser.username}`,
+        });
+    }
+
+    private async writeSolidxAdminApiKeyConfig(generatedApiKey: {
+        apiKey: string;
+        record: {
+            id: number;
+            name: string;
+            maskedKey: string;
+            isActive: boolean;
+            expiresAt: Date | null;
+            createdAt?: Date;
+            updatedAt?: Date;
+        };
+    }) {
+        const consumingProjectRoot = path.resolve(process.cwd(), '..');
+        const consumingProjectName = path.basename(consumingProjectRoot);
+        const solidxDir = path.join(os.homedir(), '.solidx', consumingProjectName);
+        const configPath = path.join(solidxDir, 'mcp.json');
+        await fs.promises.mkdir(solidxDir, { recursive: true });
+
+        let existingConfig: Record<string, any> = {};
+
+        if (fs.existsSync(configPath)) {
+            const rawConfig = await fs.promises.readFile(configPath, 'utf8');
+            if (rawConfig.trim()) {
+                const parsedConfig = JSON.parse(rawConfig);
+                if (parsedConfig && typeof parsedConfig === 'object' && !Array.isArray(parsedConfig)) {
+                    existingConfig = parsedConfig;
+                } else {
+                    this.logger.warn(`Expected ${configPath} to contain a JSON object. Overwriting with a new object.`);
+                }
+            }
+        }
+
+        const nextConfig = {
+            ...existingConfig,
+            solidxAdminApiKey: {
+                id: generatedApiKey.record.id,
+                name: generatedApiKey.record.name,
+                apiKey: generatedApiKey.apiKey,
+                maskedKey: generatedApiKey.record.maskedKey,
+                isActive: generatedApiKey.record.isActive,
+                expiresAt: generatedApiKey.record.expiresAt,
+                createdAt: generatedApiKey.record.createdAt,
+                updatedAt: generatedApiKey.record.updatedAt,
+            },
+        };
+
+        await fs.promises.writeFile(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, 'utf8');
+    }
+
     // OK
     private async seedModuleModelFields(moduleMetadata: CreateModuleMetadataDto): Promise<{ pruned: number; upserted: number }> {
         const fieldMetadataRepo = this.dataSource.getRepository(FieldMetadata);
@@ -1872,6 +2020,48 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private async handleSeedLocales(localesDto: CreateLocaleDto[]) {
+        if (!localesDto || localesDto.length === 0) {
+            this.logger.debug(`No locales found to seed`);
+            return;
+        }
+
+        for (const dto of localesDto) {
+            if (dto.isDefault) {
+                const existingDefaultLocales = await this.localeRepo.find({
+                    where: {
+                        isDefault: true,
+                    } as any,
+                });
+
+                for (const locale of existingDefaultLocales) {
+                    if (locale.locale !== dto.locale) {
+                        await this.localeRepo.save({
+                            ...locale,
+                            isDefault: false,
+                        });
+                    }
+                }
+            }
+
+            const existingLocale = await this.localeRepo.findOne({
+                where: {
+                    locale: dto.locale,
+                } as any,
+            });
+
+            await this.localeRepo.save(
+                this.localeRepo.create({
+                    ...existingLocale,
+                    ...dto,
+                })
+            );
+        }
+
+        const locales = await this.localeRepo.find();
+        this.solidRegistry.registerlocales(locales);
+    }
+
     private validateSavedFilterQueryJsonWrapper(dto: CreateSavedFiltersDto): void {
         const filterName = dto?.name ?? '<unnamed>';
         const filterQueryJson = dto?.filterQueryJson;