@solidxai/core 0.1.12 → 0.1.13-beta.10

package/src/repository/workflow-trigger-execution.repository.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { WorkflowTriggerExecution } from '../entities/workflow-trigger-execution.entity';
+
+@Injectable()
+export class WorkflowTriggerExecutionRepository extends SolidBaseRepository<WorkflowTriggerExecution> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowTriggerExecution, dataSource, requestContextService, securityRuleRepository);
+    }
+}

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

@@ -3,6 +3,7 @@ import { EventEmitter2 } from '@nestjs/event-emitter';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { createHash } from 'crypto';
 import { v4 as uuidv4 } from 'uuid';
 
 import { CreateEmailTemplateDto } from 'src/dtos/create-email-template.dto';
@@ -66,6 +67,7 @@ import { FieldMetadata } from 'src/entities/field-metadata.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
 import { ViewMetadata } from 'src/entities/view-metadata.entity';
+import { WorkflowDefinition } from 'src/entities/workflow-definition.entity';
 import { EventDetails, EventType, ModuleMetadataSeederEventPayload } from 'src/interfaces';
 
 /**
@@ -146,24 +148,30 @@ export class ModuleMetadataSeederService {
         let modulesToSeed: string[] | null = null;
         const requestedModulesToSeed = Array.isArray(conf?.modulesToSeed) ? [...conf.modulesToSeed] : null;
         const shouldSeedGlobalMetadata = conf?.seedGlobalMetadata !== false;
+        const skipHooks = Boolean(conf?.skipHooks);
         const seedOptions: ModuleMetadataSeederEventPayload['options'] = {
             modulesToSeed: requestedModulesToSeed,
             pruneMetadata: Boolean(conf?.pruneMetadata),
             seedGlobalMetadata: shouldSeedGlobalMetadata,
+            skipHooks,
         };
         const seedRunId = uuidv4();
         const startedAt = new Date();
         const seededModuleNames: string[] = [];
 
-        this.emitModuleMetadataSeederEvent(
-            EventType.MODULE_METADATA_SEEDER_STARTED,
-            {
-                seedRunId,
-                options: seedOptions,
-                startedAt: startedAt.toISOString(),
-                currentStep,
-            },
-        );
+        if (skipHooks) {
+            console.log('▶ Skipping pre-seed hooks (--skip-hooks).');
+        } else {
+            this.emitModuleMetadataSeederEvent(
+                EventType.MODULE_METADATA_SEEDER_STARTED,
+                {
+                    seedRunId,
+                    options: seedOptions,
+                    startedAt: startedAt.toISOString(),
+                    currentStep,
+                },
+            );
+        }
 
         try {
             this.enablePruning = Boolean(conf?.pruneMetadata);
@@ -236,10 +244,15 @@ 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 = 'seedWorkflowDefinitions';
+                        this.logger.log(`Seeding Workflow Definitions`);
+                        const workflowDefinitionCounts = await this.timeOperation('seed-workflow-definitions', () => this.seedWorkflowDefinitions(moduleMetadata, overallMetadata), { moduleName: moduleMetadata.name, component: 'workflow-definitions' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Workflow Definitions', workflowDefinitionCounts)}`);
+
+                        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`);
@@ -316,37 +329,45 @@ export class ModuleMetadataSeederService {
             // Add a console log indicating seeding is finished. This needs to be console.log so that it looks proper when this code is run via CLI.
             console.log(`✔ Seeding completed.`);
             //this.logger.log(`All Seeders finished`);
-            await this.emitModuleMetadataSeederFinishedEvent(
-                EventType.MODULE_METADATA_SEEDER_FINISHED,
-                {
-                    seedRunId,
-                    options: seedOptions,
-                    startedAt: startedAt.toISOString(),
-                    finishedAt: new Date().toISOString(),
-                    durationMs: Date.now() - startedAt.getTime(),
-                    success: true,
-                    seededModuleNames,
-                    currentStep,
-                },
-            );
+            if (skipHooks) {
+                console.log('▶ Skipping post-seed hooks (--skip-hooks).');
+            } else {
+                await this.emitModuleMetadataSeederFinishedEvent(
+                    EventType.MODULE_METADATA_SEEDER_FINISHED,
+                    {
+                        seedRunId,
+                        options: seedOptions,
+                        startedAt: startedAt.toISOString(),
+                        finishedAt: new Date().toISOString(),
+                        durationMs: Date.now() - startedAt.getTime(),
+                        success: true,
+                        seededModuleNames,
+                        currentStep,
+                    },
+                );
+            }
 
             //FIXME: Handle displaying the created users credentials in a better way.
             // this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);
         } catch (error: any) {
-            await this.emitModuleMetadataSeederFinishedEvent(
-                EventType.MODULE_METADATA_SEEDER_FINISHED,
-                {
-                    seedRunId,
-                    options: seedOptions,
-                    startedAt: startedAt.toISOString(),
-                    finishedAt: new Date().toISOString(),
-                    durationMs: Date.now() - startedAt.getTime(),
-                    success: false,
-                    seededModuleNames,
-                    currentStep,
-                    errorMessage: error?.message,
-                },
-            );
+            if (skipHooks) {
+                console.log('▶ Skipping post-seed hooks (--skip-hooks).');
+            } else {
+                await this.emitModuleMetadataSeederFinishedEvent(
+                    EventType.MODULE_METADATA_SEEDER_FINISHED,
+                    {
+                        seedRunId,
+                        options: seedOptions,
+                        startedAt: startedAt.toISOString(),
+                        finishedAt: new Date().toISOString(),
+                        durationMs: Date.now() - startedAt.getTime(),
+                        success: false,
+                        seededModuleNames,
+                        currentStep,
+                        errorMessage: error?.message,
+                    },
+                );
+            }
             this.logSeedFailureForCli(error, {
                 moduleName: currentModule,
                 step: currentStep,
@@ -550,6 +571,28 @@ export class ModuleMetadataSeederService {
         return { pruned, upserted: savedFilters.length };
     }
 
+    private async seedWorkflowDefinitions(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
+        const workflowDefinitions = this.getSeedArray<any>(overallMetadata?.workflowDefinitions)
+            .map((definition) => ({
+                ...definition,
+                moduleUserKey: definition.moduleUserKey ?? moduleMetadata.name,
+                definitionYaml: this.resolveSeedFileBackedWorkflowDefinitionYaml(definition.definitionYaml, overallMetadata?.__seedFilePath),
+            }));
+        const pruned = this.enablePruning ? await this.timeOperation('prune-workflow-definitions', () => this.pruneWorkflowDefinitions(workflowDefinitions, moduleMetadata.name), {
+            moduleName: moduleMetadata.name,
+            component: 'workflow-definitions',
+            serviceCall: 'pruneWorkflowDefinitions',
+        }) : 0;
+        if (workflowDefinitions.length > 0) {
+            await this.timeOperation('handle-workflow-definitions', () => this.handleSeedWorkflowDefinitions(workflowDefinitions), {
+                moduleName: moduleMetadata.name,
+                component: 'workflow-definitions',
+                serviceCall: 'handleSeedWorkflowDefinitions',
+            });
+        }
+        return { pruned, upserted: workflowDefinitions.length };
+    }
+
     private async seedListOfValues(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         const listOfValues = this.getSeedArray<CreateListOfValuesDto>(overallMetadata?.listOfValues);
         const pruned = this.enablePruning ? await this.timeOperation('prune-list-of-values', () => this.pruneListOfValues(listOfValues, moduleMetadata.name), {
@@ -785,6 +828,7 @@ export class ModuleMetadataSeederService {
 
             if (fs.existsSync(fullPath)) {
                 const overallMetadata = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+                overallMetadata.__seedFilePath = fullPath;
                 seedDataFiles.push(overallMetadata);
             }
         }
@@ -792,6 +836,28 @@ export class ModuleMetadataSeederService {
         return seedDataFiles;
     }
 
+    private resolveSeedFileBackedWorkflowDefinitionYaml(definitionYaml: string, seedFilePath?: string): string {
+        if (typeof definitionYaml !== 'string' || !definitionYaml.startsWith('file:')) {
+            return definitionYaml;
+        }
+
+        if (!seedFilePath) {
+            throw new Error(`Cannot resolve workflow definition YAML file reference "${definitionYaml}" because the seed file path is unavailable.`);
+        }
+
+        const relativePath = definitionYaml.slice('file:'.length).trim();
+        if (!relativePath) {
+            throw new Error(`Cannot resolve workflow definition YAML file reference "${definitionYaml}" because no relative path was provided.`);
+        }
+
+        const resolvedPath = path.resolve(path.dirname(seedFilePath), relativePath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Workflow definition YAML file "${resolvedPath}" referenced from "${seedFilePath}" does not exist.`);
+        }
+
+        return fs.readFileSync(resolvedPath, 'utf-8');
+    }
+
     // OK
     private async seedGlobalMetadata() {
         this.logger.log(`Seeding Permissions`);
@@ -2147,6 +2213,52 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private async handleSeedWorkflowDefinitions(workflowDefinitions: any[]) {
+        if (!workflowDefinitions || workflowDefinitions.length === 0) {
+            this.logger.debug(`No workflow definitions found to seed`);
+            return;
+        }
+
+        const repo = this.dataSource.getRepository(WorkflowDefinition);
+        for (const definition of workflowDefinitions) {
+            const moduleMetadata = await this.getModuleByUserKeyCached(definition.moduleUserKey, {
+                moduleName: definition.moduleUserKey,
+                component: 'workflow-definitions',
+                details: `module=${definition.moduleUserKey}`,
+            });
+
+            if (!moduleMetadata) {
+                throw new Error(`Cannot seed workflow definition "${definition.key}": module metadata "${definition.moduleUserKey}" was not found.`);
+            }
+
+            const existing = await repo.findOne({
+                where: {
+                    key: definition.key,
+                } as any,
+            });
+            const payload = repo.create({
+                ...existing,
+                key: definition.key,
+                moduleMetadata,
+                displayName: definition.displayName,
+                namespace: definition.namespace,
+                description: definition.description,
+                status: definition.status ?? 'active',
+                definitionVersion: definition.definitionVersion,
+                definitionChecksum: this.workflowDefinitionChecksum(definition.definitionYaml),
+                definitionYaml: definition.definitionYaml,
+                tags: definition.tags,
+            });
+
+            await this.timeOperation('workflow-definition-save', () => repo.save(payload), {
+                moduleName: definition.moduleUserKey,
+                component: 'workflow-definitions',
+                serviceCall: 'workflowDefinitionRepository.save',
+                details: `workflow=${definition.key}`,
+            });
+        }
+    }
+
     private async handleSeedLocales(localesDto: CreateLocaleDto[]) {
         if (!localesDto || localesDto.length === 0) {
             this.logger.debug(`No locales found to seed`);
@@ -2396,6 +2508,49 @@ export class ModuleMetadataSeederService {
         return 0;
     }
 
+    private async pruneWorkflowDefinitions(workflowDefinitionsDto: any[] | undefined, moduleName?: string): Promise<number> {
+        if (!moduleName) {
+            this.logger.warn(`Skipping workflow definition prune: missing module name in metadata.`);
+            return 0;
+        }
+        const workflowDefinitions = workflowDefinitionsDto ?? [];
+
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'workflow-definitions',
+            details: `module=${moduleName}`,
+        });
+        if (!module) {
+            this.logger.warn(`Skipping workflow definition prune: module not found for ${moduleName}.`);
+            return 0;
+        }
+
+        const workflowKeys = [...new Set(workflowDefinitions.map(dto => dto.key).filter(Boolean))];
+        const repo = this.dataSource.getRepository(WorkflowDefinition);
+        const idsToDeleteQuery = repo
+            .createQueryBuilder('workflowDefinition')
+            .select('workflowDefinition.id', 'id')
+            .innerJoin('workflowDefinition.moduleMetadata', 'moduleMetadata')
+            .where('moduleMetadata.id = :moduleId', { moduleId: module.id });
+
+        if (workflowKeys.length > 0) {
+            idsToDeleteQuery.andWhere('workflowDefinition.key NOT IN (:...workflowKeys)', { workflowKeys });
+        }
+
+        const rows = await idsToDeleteQuery.getRawMany();
+        const ids = rows.map((row) => row.id);
+        if (ids.length > 0) {
+            const result = await repo
+                .createQueryBuilder()
+                .delete()
+                .from(WorkflowDefinition)
+                .whereInIds(ids)
+                .execute();
+            return result.affected ?? 0;
+        }
+        return 0;
+    }
+
     private async pruneListOfValues(listOfValuesDto: CreateListOfValuesDto[] | undefined, moduleName?: string): Promise<number> {
         if (!moduleName) {
             this.logger.warn(`Skipping list of values prune: missing module name in metadata.`);
@@ -2824,4 +2979,25 @@ export class ModuleMetadataSeederService {
         return `✔ [${moduleName}] ${label} seeded (upserted ${counts.upserted})`;
     }
 
+    private workflowDefinitionChecksum(value: any): string {
+        return createHash('sha256')
+            .update(typeof value === 'string' ? value : this.stableStringify(value))
+            .digest('hex');
+    }
+
+    private stableStringify(value: any): string {
+        if (Array.isArray(value)) {
+            return `[${value.map((entry) => this.stableStringify(entry)).join(',')}]`;
+        }
+
+        if (value && typeof value === 'object') {
+            return `{${Object.keys(value)
+                .sort()
+                .map((key) => `${JSON.stringify(key)}:${this.stableStringify(value[key])}`)
+                .join(',')}}`;
+        }
+
+        return JSON.stringify(value);
+    }
+
 }

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

@@ -12,6 +12,7 @@ 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 { InternationalisationHelperService } from 'src/services/internationalisation-helper.service';
 import { MediaRepository } from 'src/repository/media.repository';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
 import { AuthenticationService } from 'src/services/authentication.service';
@@ -30,6 +31,7 @@ export class ModuleTestDataService {
     private readonly moduleRef: ModuleRef,
     private readonly discoveryService: DiscoveryService,
     private readonly solidRegistry: SolidRegistry,
+    private readonly internationalisationHelperService: InternationalisationHelperService,
   ) {}
 
   async setupTestData(modulesToTest?: string[]): Promise<void> {
@@ -246,6 +248,10 @@ export class ModuleTestDataService {
       const entityRepo = this.resolveRepository(modelUserKey);
       const payload: Record<string, any> = { ...(entry.data ?? {}) };
 
+      if (modelDef.internationalisation && !payload.localeName) {
+        payload.localeName = this.internationalisationHelperService.resolveDefaultLocaleName(this.solidRegistry);
+      }
+
       for (const field of modelDef.fields ?? []) {
         if (field.type === 'relation' && field.relationType === 'many-to-one') {
           const userKeyProp = `${field.name}UserKey`;