@solidxai/core 0.1.6-beta.2 → 0.1.6-beta.21

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

@@ -11,6 +11,7 @@ export interface MediaFieldOptions {
     fieldName: string | undefined | null;
     mediaMaxSizeKb: number | undefined | null;
     mediaTypes: string[];
+    isUpdate: boolean | undefined | null;
 }
 
 type MediaType = 'image' | 'audio' | 'video' | 'file' | 'pdf';
@@ -119,25 +120,24 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     }
 
     validate(dto: any, files: Array<Express.Multer.File>): ValidationError[] {
-        const isValidateForUpdate = dto.id !== undefined; //FIXME: This is a hack, since we are using PUT for update. Once we support PATCH, this will be removed
         const fieldFiles = files.filter(file => file.fieldname === this.options.fieldName);
-        return this.applyValidations(fieldFiles, isValidateForUpdate);
+        return this.applyValidations(fieldFiles);
     }
 
-    private applyValidations(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private applyValidations(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         switch (this.options.type) {
             case SolidMediaType.mediaSingle:
-                return this.validateMediaSingle(fieldFiles, isValidateForUpdate);
+                return this.validateMediaSingle(fieldFiles);
             case SolidMediaType.mediaMultiple:
-                return this.validateMediaMultiple(fieldFiles, isValidateForUpdate);
+                return this.validateMediaMultiple(fieldFiles);
             default:
                 return [];
         }
     }
 
-    private validateMediaSingle(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private validateMediaSingle(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
-        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+        if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({
                 field: this.options.fieldName,
                 error: `${this.options.fieldName} is required`
@@ -184,9 +184,9 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         return errors;
     }
 
-    private validateMediaMultiple(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private validateMediaMultiple(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
-        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+        if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({
                 field: this.options.fieldName,
                 error: `${this.options.fieldName} is required`

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

@@ -7,7 +7,7 @@ export interface SelectionDynamicFieldOptions {
     selectionDynamicProvider: string;
     selectionValueType: SelectionValueType;
     required: boolean | undefined | null;
-    selectionDynamicProviderCtxt: any;
+    selectionDynamicProviderCtxt: ISelectionProviderContext;
     fieldName: string;
     discoveryService: DiscoveryService;
     isMultiSelect: boolean | undefined | null;
@@ -85,8 +85,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
     private async applyFormatValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];
         !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value type is invalid' }) : "no errors";
-        const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider)
-        !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        const ctxt = this.options.selectionDynamicProviderCtxt;
+        if (ctxt.validateOnSave !== false) {
+            const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider, ctxt);
+            !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        }
         return errors;
     }
 
@@ -106,11 +109,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
     }
 
-    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string): Promise<boolean> {
+    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string, ctxt: ISelectionProviderContext): Promise<boolean> {
         const providerInstance = this.providerInstance<any>(selectionDynamicProvider);
         try {
             // Use the value method first
-            const valueOption = await providerInstance.value(fieldValue, JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const valueOption = await providerInstance.value(fieldValue, ctxt);
             if (valueOption && valueOption.value === fieldValue) {
                 return true;
             }
@@ -118,7 +121,7 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
         catch (error) {
             // Use the values method as a fallback, if the value method is not implemented
-            const values = await providerInstance.values('', JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const values = await providerInstance.values('', ctxt);
             const isValid = values.some(v => v.value === fieldValue);
             return isValid;
         }

package/src/helpers/solid-registry.ts

@@ -5,12 +5,8 @@ import { CommonEntity } from 'src/entities/common.entity';
 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 { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule, ISettingsProvider, SettingDefinition } from "../interfaces";
-import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
 import { ObjectLiteral } from 'typeorm';
-import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
-import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
-import { Setting } from 'src/entities/setting.entity';
 
 type ControllerMetadata = {
   name: string;

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

@@ -9,6 +9,29 @@ const LONG_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
     [DatasourceType.oracle]: { type: "clob" },
 };
 
+// For simple-json columns that may contain large payloads: on MySQL/MariaDB the default
+// TEXT backing store is limited to 64 KB, so we override the type to longtext and supply
+// an explicit JSON transformer so TypeORM still serialises/deserialises correctly.
+const SIMPLE_JSON_LARGE_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: {},
+    [DatasourceType.mssql]: {},
+    [DatasourceType.mysql]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.mariadb]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.oracle]: { type: "clob" },
+};
+
 const solidCoreDbType: DatasourceType =
     Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
         ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
@@ -20,6 +43,9 @@ export function getColumnType(solidType: string): ColumnOptions {
         case "richText":
             return LONG_TEXT_MAP[solidCoreDbType];
 
+        case "simpleJsonLargeText":
+            return SIMPLE_JSON_LARGE_TEXT_MAP[solidCoreDbType];
+
         default:
             return {};
     }

package/src/index.ts

@@ -137,6 +137,7 @@ export * from './entities/user-activity-history.entity'
 export * from './entities/dashboard.entity'
 export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
+export * from './entities/dashboard-layout.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
 export * from './entities/model-sequence.entity'
@@ -175,7 +176,9 @@ export * from './helpers/field-crud-managers/SelectionDynamicFieldCrudManager' /
 export * from './helpers/field-crud-managers/SelectionStaticFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/ShortTextFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/UUIDFieldCrudManager' //rename
+export * from './helpers/bootstrap.helper'
 export * from './helpers/environment.helper'
+export * from './helpers/cache.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
 export * from './helpers/model-metadata-helper.service'

package/src/interfaces.ts

@@ -111,6 +111,8 @@ export interface ISelectionProviderContext {
   limit: number;
   offset: number;
   formValues: Record<string, any>;
+  //Attribute to control the validation on creating the record
+  validateOnSave?: boolean;
   // query: string;
 }
 
@@ -136,12 +138,18 @@ export interface IMcpToolResponseHandler {
   apply(aiInteraction: AiInteraction);
 }
 
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+    expressions?: SqlExpression[]
+}
 export interface IDashboardQuestionDataProvider<TContext, TData> {
   help(): string;
 
   name(): string;
 
-  getData(question: DashboardQuestion, expressions?: SqlExpression[], ctxt?: TContext): Promise<TData[] | TData>;
+  getData(question: DashboardQuestion, ctxt?: TContext): Promise<TData[] | TData>;
 }
 
 /**

package/src/jobs/computed-field-evaluation-queue-options.ts

@@ -6,4 +6,5 @@ export default {
     name: QUEUE_NAME,
     type: BrokerType.RabbitMQ,
     queueName: QUEUE_NAME,
+    prefetch: 10,
 };

package/src/repository/dashboard-layout.repository.ts

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

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

@@ -140,17 +140,17 @@ export class ModuleMetadataSeederService {
                 console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
                 this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
 
+                currentStep = 'seedMediaStorageProviders';
+                this.logger.log(`Seeding Media Storage Providers`);
+                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
+                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
+
                 // Process module metadata first.
                 currentStep = 'seedModuleModelFields';
                 this.logger.log(`Seeding Module / Model / Fields`);
                 const moduleModelFieldCounts = await this.seedModuleModelFields(moduleMetadata);
                 console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
 
-                currentStep = 'seedMediaStorageProviders';
-                this.logger.log(`Seeding Media Storage Providers`);
-                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
-
                 currentStep = 'seedRoles';
                 this.logger.log(`Seeding Roles`);
                 const roleCounts = await this.seedRoles(overallMetadata);