@solidxai/core 0.1.8-beta.1 → 0.1.8-beta.11

package/src/helpers/bootstrap.helper.ts

@@ -90,6 +90,21 @@ export async function bootstrapSolidApp(
   // Security headers
   app.use(helmet(buildDefaultSecurityHeaderOptions()));
 
+  // Nest's Swagger UI HTML injects inline styles; keep CSP strict elsewhere.
+  const isSwaggerPath = (path: string) =>
+    path === '/docs' ||
+    path === '/docs/' ||
+    path.startsWith('/docs/') ||
+    path === '/docs-json' ||
+    path === '/docs-yaml';
+
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    if (isSwaggerPath(req.path)) {
+      res.removeHeader('Content-Security-Policy');
+    }
+    next();
+  });
+
   // Permissions-Policy header
   app.use((_req: Request, res: Response, next: NextFunction) => {
     res.setHeader('Permissions-Policy', buildPermissionsPolicyHeader(permissionsPolicyOverrides));
@@ -127,7 +142,7 @@ export async function bootstrapSolidApp(
 
   // Swagger
   if (swagger !== false) {
-    const { title = 'Solid Starters', description = 'Solid Starters API', version = '1.0' } = swagger;
+    const { title = process.env.SOLID_APP_NAME, description = process.env.SOLID_APP_DESCRIPTION, version = '1.0' } = swagger;
     const swaggerConfig = new DocumentBuilder()
       .setTitle(title)
       .setDescription(description)

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

@@ -128,14 +128,25 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
     }
 
     private providerInstance<T extends ISelectionProviderContext>(selectionDynamicProvider: string): ISelectionProvider<T> {
-        const provider = this.options.discoveryService
-            .getProviders()
-            .filter((provider) => provider.name === selectionDynamicProvider)
-            .pop();
-        if (!provider) {
+        const providers = this.options.discoveryService.getProviders();
+
+        const byToken = providers.find((p) => p.name === selectionDynamicProvider);
+        if (byToken) {
+            return byToken.instance as ISelectionProvider<T>;
+        }
+
+        const byName = providers.find((p) => {
+            try {
+                return typeof p.instance?.name === 'function' && p.instance.name() === selectionDynamicProvider;
+            } catch {
+                return false;
+            }
+        });
+
+        if (!byName) {
             throw new Error(`Provider for ${selectionDynamicProvider} not found`);
         }
-        return provider.instance as ISelectionProvider<T>;
+        return byName.instance as ISelectionProvider<T>;
     }
 
     private isApplyRequiredValidation(): boolean {

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

@@ -32,6 +32,14 @@ const SIMPLE_JSON_LARGE_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
     [DatasourceType.oracle]: { type: "clob" },
 };
 
+const DECIMAL_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: { type: "float4" },
+    [DatasourceType.mssql]: { type: "float" },
+    [DatasourceType.mysql]: { type: "float" },
+    [DatasourceType.mariadb]: { type: "float" },
+    [DatasourceType.oracle]: { type: "float" },
+};
+
 const solidCoreDbType: DatasourceType =
     Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
         ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
@@ -46,6 +54,9 @@ export function getColumnType(solidType: string): ColumnOptions {
         case "simpleJsonLargeText":
             return SIMPLE_JSON_LARGE_TEXT_MAP[solidCoreDbType];
 
+        case "decimal":
+            return DECIMAL_MAP[solidCoreDbType];
+
         default:
             return {};
     }

package/src/index.ts

@@ -126,6 +126,7 @@ export * from './entities/permission-metadata.entity'
 export * from './entities/role-metadata.entity'
 export * from './entities/sms-template.entity'
 export * from './entities/user.entity'
+export * from './entities/user-api-key.entity'
 export * from './entities/view-metadata.entity'
 export * from './entities/setting.entity'
 export * from './entities/saved-filters.entity'
@@ -314,6 +315,7 @@ export * from './services/user.service'
 export * from './services/view-metadata.service'
 export * from './services/whatsapp/Msg91WhatsappService' //rename
 export * from './services/setting.service'
+export * from './services/encryption.service'
 export * from './services/info.service'
 export * from './controllers/info.controller'
 export * from './services/settings/default-settings-provider.service'

package/src/interfaces.ts

@@ -70,6 +70,7 @@ export interface SettingDefinition<T = any> {
   key: string;
   value: T;
   level: SettingLevel;
+  encrypted?: boolean;
 }
 
 // solid-core/settings/settings-provider.interface.ts
@@ -395,3 +396,18 @@ export interface AwsS3Config {
 
 // Prevents inference so callers must provide explicit type arguments; reusable for other APIs.
 export type NoInfer<T> = [T][T extends any ? 0 : never];
+
+export type AuditEventType = 'insert' | 'update' | 'delete';
+
+export interface AuditQueuePayload {
+    eventType: AuditEventType;
+    modelName: string;
+    entityId: string | number | null;
+    occurredAt: string;
+    after?: any;
+    before?: any;
+    updatedColumnNames?: string[];
+    userId?: number | null;
+}
+
+

package/src/jobs/database/chatter-queue-publisher-database.service.ts

@@ -4,7 +4,7 @@ import { DatabasePublisher } from 'src/services/queues/database-publisher.servic
 import { MqMessageQueueService } from '../../services/mq-message-queue.service';
 import { MqMessageService } from '../../services/mq-message.service';
 import { QueuesModuleOptions } from "../../interfaces";
-import { AuditQueuePayload } from '../rabbitmq/chatter-queue-publisher.service';
+import { AuditQueuePayload } from '../../interfaces';
 import chatterQueueOptionsDatabase from './chatter-queue-options-database';
 
 @Injectable()

package/src/jobs/database/chatter-queue-subscriber-database.service.ts

@@ -6,7 +6,7 @@ import { MqMessageService } from '../../services/mq-message.service';
 import { MqMessageQueueService } from '../../services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../../interfaces";
 import { PollerService } from 'src/services/poller.service';
-import { AuditQueuePayload } from '../rabbitmq/chatter-queue-publisher.service';
+import { AuditQueuePayload } from '../../interfaces';
 import { ChatterMessageService } from 'src/services/chatter-message.service';
 import chatterQueueOptionsDatabase from './chatter-queue-options-database';
 

package/src/jobs/rabbitmq/chatter-queue-publisher.service.ts

@@ -4,21 +4,7 @@ import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.servic
 import chatterQueueOptions from './chatter-queue-options';
 import { MqMessageQueueService } from '../../services/mq-message-queue.service';
 import { MqMessageService } from '../../services/mq-message.service';
-import { QueuesModuleOptions } from "../../interfaces";
-
-
-export type AuditEventType = 'insert' | 'update' | 'delete';
-
-export interface AuditQueuePayload {
-    eventType: AuditEventType;
-    modelName: string;              // TypeORM entity class name (e.g. 'Order')
-    entityId: string | number | null;
-    occurredAt: string;             // ISO timestamp, captured at event time
-    after?: any;                    // entity state after operation (insert/update)
-    before?: any;                   // entity state before operation (update/delete)
-    updatedColumnNames?: string[];  // propertyNames of changed columns (update only)
-    userId?: number | null;         // active user captured at event time
-}
+import { AuditQueuePayload, QueuesModuleOptions } from "../../interfaces";
 
 @Injectable()
 export class ChatterQueuePublisherRabbitmq extends RabbitMqPublisher<AuditQueuePayload> {

package/src/jobs/rabbitmq/chatter-queue-subscriber.service.ts

@@ -6,7 +6,7 @@ import { MqMessageService } from '../../services/mq-message.service';
 import { MqMessageQueueService } from '../../services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../../interfaces";
 import chatterQueueOptions from './chatter-queue-options';
-import { AuditQueuePayload } from './chatter-queue-publisher.service';
+import { AuditQueuePayload } from '../../interfaces';
 import { ChatterMessageService } from 'src/services/chatter-message.service';
 
 @Injectable()

package/src/jobs/redis/chatter-queue-subscriber-redis.service.ts

@@ -6,7 +6,7 @@ import chatterQueueConfig from './chatter-queue-options-redis';
 import { MqMessageService } from '../../services/mq-message.service';
 import { MqMessageQueueService } from '../../services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../../interfaces";
-import { AuditQueuePayload } from '../rabbitmq/chatter-queue-publisher.service';
+import { AuditQueuePayload } from '../../interfaces';
 import { ChatterMessageService } from '../../services/chatter-message.service';
 
 @Injectable()

package/src/repository/user-api-key.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { UserApiKey } from 'src/entities/user-api-key.entity';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class UserApiKeyRepository extends SolidBaseRepository<UserApiKey> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(UserApiKey, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/seeders/module-test-data.service.ts

@@ -2,15 +2,19 @@ import { Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from '@nestjs/core';
 import { getDataSourceToken } from '@nestjs/typeorm';
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { DataSource } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import * as fs from 'fs';
 import * as path from 'path';
 
 import solidCoreMetadata from './seed-data/solid-core-metadata.json';
 import { CreateModuleMetadataDto } from 'src/dtos/create-module-metadata.dto';
 import { CreateModelMetadataDto } from 'src/dtos/create-model-metadata.dto';
+import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { getDynamicModuleNamesBasedOnMetadata } from 'src/helpers/module.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
+import { MediaRepository } from 'src/repository/media.repository';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { getMediaStorageProvider } from 'src/services/mediaStorageProviders';
 
 @Injectable()
 export class ModuleTestDataService {
@@ -185,7 +189,7 @@ export class ModuleTestDataService {
       throw new Error('Module metadata missing from test data payload.');
     }
 
-    // console.log(JSON.stringify(moduleMetadata, null, 2));    
+    // console.log(JSON.stringify(moduleMetadata, null, 2));
 
     const testingData: Array<{ modelUserKey: string; data: Record<string, any> }> = overallMetadata?.testing?.data ?? [];
     if (testingData.length === 0) {
@@ -243,19 +247,174 @@ export class ModuleTestDataService {
         }
       }
 
+      // Strip media fields from entity payload — file paths cannot be saved as columns
+      const mediaPayload: Record<string, string> = {};
+      for (const field of modelDef.fields ?? []) {
+        if ((field.type === 'mediaSingle' || field.type === 'mediaMultiple') && payload[field.name] !== undefined) {
+          mediaPayload[field.name] = payload[field.name] as string;
+          delete payload[field.name];
+        }
+      }
+
+      // Strip many-to-many and one-to-many fields — these are resolved post-save via the relation builder
+      const multiRelationPayload: Array<{ field: any; userKeys: string[] }> = [];
+      for (const field of modelDef.fields ?? []) {
+        if (field.type !== 'relation') continue;
+        if (field.relationType !== 'many-to-many' && field.relationType !== 'one-to-many') continue;
+
+        const userKeysProp = `${field.name}UserKeys`;
+        if (userKeysProp in payload && Array.isArray(payload[userKeysProp])) {
+          multiRelationPayload.push({ field, userKeys: payload[userKeysProp] });
+          delete payload[userKeysProp];
+        }
+        // Remove raw field value if accidentally present
+        delete payload[field.name];
+      }
+
+      // Upsert entity, capturing the saved result for post-save steps
+      let savedEntity: any;
       const userKeyField = modelDef.userKeyFieldUserKey;
       if (userKeyField && payload[userKeyField] !== undefined) {
         const existing = await entityRepo.findOne({
           where: { [userKeyField]: payload[userKeyField] },
         });
         if (existing) {
-          await entityRepo.save(entityRepo.merge(existing, payload));
-          continue;
+          savedEntity = await entityRepo.save(entityRepo.merge(existing, payload));
+        } else {
+          savedEntity = await entityRepo.save(entityRepo.create(payload));
         }
+      } else {
+        savedEntity = await entityRepo.save(entityRepo.create(payload));
+      }
+
+      if (multiRelationPayload.length > 0) {
+        await this.seedMultiRelations(savedEntity.id, modelUserKey, multiRelationPayload, modelsByName);
+      }
+
+      if (Object.keys(mediaPayload).length > 0) {
+        await this.seedEntityMedia(savedEntity.id, modelUserKey, mediaPayload);
+      }
+    }
+  }
+
+  private async seedMultiRelations(
+    entityId: number,
+    modelUserKey: string,
+    relations: Array<{ field: any; userKeys: string[] }>,
+    modelsByName: Map<string, CreateModelMetadataDto>,
+  ): Promise<void> {
+    for (const { field, userKeys } of relations) {
+      if (!userKeys.length) continue;
+
+      const coModelName = field.relationCoModelSingularName;
+      const coModelDef = modelsByName.get(coModelName);
+      if (!coModelDef) {
+        throw new Error(`Relation model "${coModelName}" not found in metadata for field ${modelUserKey}.${field.name}`);
+      }
+      const coUserKeyField = coModelDef.userKeyFieldUserKey;
+      if (!coUserKeyField) {
+        throw new Error(`Relation model "${coModelName}" is missing userKeyFieldUserKey, needed to resolve ${modelUserKey}.${field.name}`);
+      }
+
+      const coRepo = this.resolveRepository(coModelName);
+      const resolvedIds: number[] = [];
+      for (const uk of userKeys) {
+        const related = typeof coRepo.findOneByUserKey === 'function'
+          ? await coRepo.findOneByUserKey(uk)
+          : await coRepo.findOne({ where: { [coUserKeyField]: uk } });
+        if (!related) {
+          throw new Error(`Related entity not found: ${coModelName}.${coUserKeyField}=${uk}`);
+        }
+        resolvedIds.push(related.id);
+      }
+
+      // Load currently associated entities to diff (set semantics — idempotent)
+      const existingRelated: any[] = await this.entityManager
+        .createQueryBuilder()
+        .relation(classify(modelUserKey), field.name)
+        .of(entityId)
+        .loadMany();
+      const existingIds: number[] = existingRelated.map((e) => e.id);
+
+      const toAdd = resolvedIds.filter((id) => !existingIds.includes(id));
+      const toRemove = existingIds.filter((id) => !resolvedIds.includes(id));
+
+      if (toAdd.length > 0 || toRemove.length > 0) {
+        await this.entityManager
+          .createQueryBuilder()
+          .relation(classify(modelUserKey), field.name)
+          .of(entityId)
+          .addAndRemove(toAdd, toRemove);
       }
 
-      await entityRepo.save(entityRepo.create(payload));
+      this.logger.debug(`Seeded ${field.relationType} relation ${modelUserKey}.${field.name} entityId=${entityId}: +${toAdd.length} -${toRemove.length}`);
+    }
+  }
+
+  private async seedEntityMedia(
+    entityId: number,
+    modelUserKey: string,
+    mediaPayload: Record<string, string>,
+  ): Promise<void> {
+    const mediaBasePath = process.env.TEST_UPLOADS_MEDIA_FILE_PATH;
+    if (!mediaBasePath) {
+      throw new Error('TEST_UPLOADS_MEDIA_FILE_PATH is not set. Cannot seed test media.');
     }
+
+    const modelMetadata = await this.modelMetadataService.findOneBySingularName(modelUserKey, {
+      fields: {
+        model: { userKeyField: true },
+        mediaStorageProvider: true,
+      },
+    });
+
+    for (const [fieldName, fileName] of Object.entries(mediaPayload)) {
+      if (!fileName) continue;
+
+      const fieldMetadata = modelMetadata.fields.find((f) => f.name === fieldName);
+      if (!fieldMetadata) {
+        throw new Error(`Media field "${fieldName}" not found in loaded metadata for model ${modelUserKey}`);
+      }
+      if (!fieldMetadata.mediaStorageProvider) {
+        throw new Error(`Media field "${fieldName}" in model ${modelUserKey} has no storage provider configured`);
+      }
+
+      const storageProviderType = fieldMetadata.mediaStorageProvider.type as MediaStorageProviderType;
+      if (storageProviderType !== MediaStorageProviderType.Filesystem) {
+        throw new Error(`Test media seeding supports filesystem storage only. Field "${fieldName}" uses "${storageProviderType}".`);
+      }
+
+      // Idempotency: skip if media already exists for this entity + field
+      const existing = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(
+        entityId, fieldMetadata.id, fieldMetadata.model.id,
+      );
+      if (existing.length > 0) {
+        this.logger.debug(`Media already seeded for ${modelUserKey}.${fieldName} entityId=${entityId}, skipping`);
+        continue;
+      }
+
+      const sourcePath = path.join(mediaBasePath, fileName);
+      if (!fs.existsSync(sourcePath)) {
+        throw new Error(`Test media file not found: ${sourcePath}`);
+      }
+
+      const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+      const stream = fs.createReadStream(sourcePath);
+      await storageProvider.storeStreams([[stream, fileName]], { id: entityId }, fieldMetadata);
+      this.logger.debug(`Seeded media for ${modelUserKey}.${fieldName} entityId=${entityId} file=${fileName}`);
+    }
+  }
+
+  private get entityManager(): EntityManager {
+    return this.moduleRef.get(EntityManager, { strict: false });
+  }
+
+  private get modelMetadataService(): ModelMetadataService {
+    return this.moduleRef.get(ModelMetadataService, { strict: false });
+  }
+
+  private get mediaRepository(): MediaRepository {
+    return this.moduleRef.get(MediaRepository, { strict: false });
   }
 
   private resolveRepository(modelUserKey: string): any {
@@ -308,7 +467,7 @@ export class ModuleTestDataService {
         if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) {
           return line;
         }
-        const [rawKey, ...rest] = line.split('=');
+        const [rawKey] = line.split('=');
         const key = rawKey.trim();
         if (!key.endsWith('_DATABASE_NAME')) {
           return line;