@solidxai/core 0.1.12 → 0.1.13-beta.2

package/src/services/workflow/workflow-scheduled-trigger.job.ts

@@ -0,0 +1,33 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ScheduledJobProvider } from 'src/decorators/scheduled-job-provider.decorator';
+import { ScheduledJob } from 'src/entities/scheduled-job.entity';
+import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
+import { WorkflowDefinitionService } from '../workflow-definition.service';
+
+@Injectable()
+@ScheduledJobProvider()
+export class WorkflowScheduledTriggerJobService implements IScheduledJob {
+  private readonly logger = new Logger(WorkflowScheduledTriggerJobService.name);
+
+  constructor(
+    private readonly workflowDefinitionService: WorkflowDefinitionService,
+  ) {}
+
+  async execute(job: ScheduledJob): Promise<void> {
+    const now = new Date();
+    const windowStart =
+      job.lastRunAt instanceof Date
+        ? job.lastRunAt
+        : new Date(now.getTime() - 5 * 60 * 1000);
+
+    const result =
+      await this.workflowDefinitionService.executeDueScheduledTriggers(
+        windowStart,
+        now,
+      );
+
+    this.logger.log(
+      `Evaluated ${result.evaluated} scheduled workflow trigger(s), triggered ${result.triggered}, skipped ${result.skipped}.`,
+    );
+  }
+}

package/src/services/workflow-definition.service.ts

@@ -0,0 +1,293 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowDefinition } from '../entities/workflow-definition.entity';
+import { WorkflowDefinitionRepository } from '../repository/workflow-definition.repository';
+import { ExecuteWorkflowDto } from '../dtos/execute-workflow.dto';
+import { WorkflowRuntimeService } from './workflow/workflow-runtime.service';
+import {
+  WorkflowDefinitionDsl,
+  WorkflowTriggerDefinition,
+} from '../types/workflow-dsl.types';
+import { WorkflowDefinitionValidatorService } from './workflow/workflow-definition-validator.service';
+import { CronExpressionParser } from 'cron-parser';
+import YAML from 'yaml';
+import { WorkflowDefinitionMetadataSyncService } from './workflow/workflow-definition-metadata-sync.service';
+
+@Injectable()
+export class WorkflowDefinitionService extends CRUDService<WorkflowDefinition>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowDefinitionRepository,
+    readonly moduleRef: ModuleRef,
+    private readonly workflowRuntimeService: WorkflowRuntimeService,
+    private readonly workflowDefinitionValidator: WorkflowDefinitionValidatorService,
+    private readonly workflowDefinitionMetadataSyncService: WorkflowDefinitionMetadataSyncService,
+      
+ ) {
+   super(entityManager, repo, 'workflowDefinition', 'solid-core', moduleRef);
+ }
+
+  async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<WorkflowDefinition> {
+    const savedDefinition = await super.create(createDto, files, solidRequestContext);
+    const populatedDefinition = await this.loadDefinitionWithModule(savedDefinition.id);
+    await this.workflowDefinitionMetadataSyncService.upsertWorkflowDefinition(populatedDefinition);
+    return savedDefinition;
+  }
+
+  async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<WorkflowDefinition[]> {
+    const savedDefinitions = await super.insertMany(createDtos, filesArray, solidRequestContext);
+    for (const savedDefinition of savedDefinitions) {
+      const populatedDefinition = await this.loadDefinitionWithModule(savedDefinition.id);
+      await this.workflowDefinitionMetadataSyncService.upsertWorkflowDefinition(populatedDefinition);
+    }
+    return savedDefinitions;
+  }
+
+  async update(
+    id: number,
+    updateDto: any,
+    files: Express.Multer.File[] = [],
+    isPartialUpdate = false,
+    solidRequestContext: any = {},
+    isUpdate = false,
+  ): Promise<WorkflowDefinition> {
+    const previousDefinition = await this.loadDefinitionWithModule(id);
+    const savedDefinition = await super.update(id, updateDto, files, isPartialUpdate, solidRequestContext, isUpdate);
+    const populatedDefinition = await this.loadDefinitionWithModule(savedDefinition.id);
+    await this.workflowDefinitionMetadataSyncService.upsertWorkflowDefinition(
+      populatedDefinition,
+      previousDefinition,
+    );
+    return savedDefinition;
+  }
+
+  async delete(id: number, solidRequestContext: any = {}) {
+    const previousDefinition = await this.loadDefinitionWithModule(id);
+    const result = await super.delete(id, solidRequestContext);
+    await this.workflowDefinitionMetadataSyncService.removeWorkflowDefinition(previousDefinition);
+    return result;
+  }
+
+  async deleteMany(ids: number[], solidRequestContext: any = {}): Promise<any> {
+    const previousDefinitions = await this.entityManager.find(WorkflowDefinition, {
+      where: ids.map((id) => ({ id })) as any,
+      relations: ['moduleMetadata'],
+    });
+    const result = await super.deleteMany(ids, solidRequestContext);
+    for (const previousDefinition of previousDefinitions) {
+      await this.workflowDefinitionMetadataSyncService.removeWorkflowDefinition(previousDefinition);
+    }
+    return result;
+  }
+
+  async recover(id: number, solidRequestContext: any = {}) {
+    const result = await super.recover(id, solidRequestContext);
+    const populatedDefinition = await this.loadDefinitionWithModule(id);
+    await this.workflowDefinitionMetadataSyncService.upsertWorkflowDefinition(populatedDefinition);
+    return result;
+  }
+
+  async recoverMany(ids: number[], solidRequestContext: any = {}) {
+    const result = await super.recoverMany(ids, solidRequestContext);
+    const recoveredDefinitions = await this.entityManager.find(WorkflowDefinition, {
+      where: ids.map((id) => ({ id })) as any,
+      relations: ['moduleMetadata'],
+    });
+    for (const recoveredDefinition of recoveredDefinitions) {
+      await this.workflowDefinitionMetadataSyncService.upsertWorkflowDefinition(recoveredDefinition);
+    }
+    return result;
+  }
+
+  validateWorkflowDefinition(definitionYaml: string) {
+    const definition = this.parseDefinitionYaml(definitionYaml);
+    this.workflowDefinitionValidator.validate(definition);
+    return {
+      valid: true,
+      message: 'Workflow definition is valid.',
+    };
+  }
+
+  executeWorkflow(id: number, request: ExecuteWorkflowDto) {
+    return this.workflowRuntimeService.executeDefinitionById(id, request ?? {});
+  }
+
+  executeWorkflowAsync(id: number, request: ExecuteWorkflowDto) {
+    return this.workflowRuntimeService.executeDefinitionByIdAsync(id, request ?? {});
+  }
+
+  executeWorkflowByKey(key: string, request: ExecuteWorkflowDto) {
+    return this.workflowRuntimeService.executeDefinitionByKey(key, request ?? {});
+  }
+
+  executeWorkflowByKeyAsync(key: string, request: ExecuteWorkflowDto) {
+    return this.workflowRuntimeService.executeDefinitionByKeyAsync(key, request ?? {});
+  }
+
+  async executeWorkflowWebhook(
+    reference: string,
+    request: ExecuteWorkflowDto,
+  ) {
+    const definition = await this.findDefinitionByReference(reference);
+    if (!definition) {
+      throw new BadRequestException('Workflow definition not found.');
+    }
+
+    const dsl = this.parseDefinitionYaml(definition.definitionYaml);
+    this.workflowDefinitionValidator.validate(dsl);
+
+    const hasActiveWebhook = (dsl.triggers ?? []).some(
+      (trigger) => trigger.type === 'webhook' && !trigger.disabled,
+    );
+    if (!hasActiveWebhook) {
+      throw new BadRequestException(
+        'Workflow does not have an active webhook trigger.',
+      );
+    }
+
+    return this.workflowRuntimeService.executeDefinitionById(definition.id, {
+      ...(request ?? {}),
+      triggerType: 'webhook',
+    });
+  }
+
+  async executeDueScheduledTriggers(
+    windowStart: Date,
+    now = new Date(),
+  ): Promise<{ evaluated: number; triggered: number; skipped: number }> {
+    const definitions = await this.entityManager.find(WorkflowDefinition, {
+      where: { status: 'active' } as any,
+    });
+
+    let evaluated = 0;
+    let triggered = 0;
+    let skipped = 0;
+
+    for (const definition of definitions) {
+      const dsl = this.safeParseDefinitionYaml(definition.definitionYaml);
+      if (!dsl) {
+        skipped += 1;
+        continue;
+      }
+
+      const triggers = (dsl.triggers ?? []).filter(
+        (trigger) => trigger.type === 'schedule' && !trigger.disabled,
+      );
+
+      for (const trigger of triggers) {
+        evaluated += 1;
+
+        if (!this.isScheduleTriggerDue(trigger, windowStart, now)) {
+          skipped += 1;
+          continue;
+        }
+
+        this.workflowDefinitionValidator.validate(dsl);
+        await this.workflowRuntimeService.executeDefinitionById(definition.id, {
+          input: this.buildDefaultInputPayload(dsl.inputs ?? {}),
+          triggerType: 'schedule',
+        });
+        triggered += 1;
+      }
+    }
+
+    return { evaluated, triggered, skipped };
+  }
+
+  private parseDefinitionYaml(definitionYaml: string): WorkflowDefinitionDsl {
+    try {
+      const parsed = YAML.parse(definitionYaml);
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new BadRequestException('Workflow definition YAML must resolve to an object.');
+      }
+      return parsed as WorkflowDefinitionDsl;
+    } catch (error: any) {
+      throw new BadRequestException(
+        error?.message ?? 'Workflow definition YAML could not be parsed.',
+      );
+    }
+  }
+
+  private safeParseDefinitionYaml(definitionYaml: string): WorkflowDefinitionDsl | null {
+    try {
+      return this.parseDefinitionYaml(definitionYaml);
+    } catch {
+      return null;
+    }
+  }
+
+  private async findDefinitionByReference(
+    reference: string,
+  ): Promise<WorkflowDefinition | null> {
+    const trimmedReference = String(reference ?? '').trim();
+    if (!trimmedReference) {
+      throw new BadRequestException('Workflow reference is required.');
+    }
+
+    const numericId = Number(trimmedReference);
+    if (Number.isInteger(numericId) && numericId > 0) {
+      const byId = await this.entityManager.findOne(WorkflowDefinition, {
+        where: { id: numericId } as any,
+      });
+      if (byId) {
+        return byId;
+      }
+    }
+
+    return this.entityManager.findOne(WorkflowDefinition, {
+      where: { key: trimmedReference } as any,
+    });
+  }
+
+  private async loadDefinitionWithModule(id: number): Promise<WorkflowDefinition> {
+    const definition = await this.entityManager.findOne(WorkflowDefinition, {
+      where: { id } as any,
+      relations: ['moduleMetadata'],
+      withDeleted: true,
+    });
+
+    if (!definition) {
+      throw new BadRequestException(`Workflow definition ${id} not found.`);
+    }
+
+    return definition;
+  }
+
+  private isScheduleTriggerDue(
+    trigger: WorkflowTriggerDefinition,
+    windowStart: Date,
+    now: Date,
+  ): boolean {
+    const cronExpression =
+      trigger.configuration?.cronExpression ?? trigger.configuration?.cron;
+    if (!cronExpression || typeof cronExpression !== 'string') {
+      return false;
+    }
+
+    try {
+      const interval = CronExpressionParser.parse(cronExpression, {
+        currentDate: windowStart,
+        tz: trigger.configuration?.timezone ?? 'UTC',
+      });
+      const nextRun = interval.next().toDate();
+      return nextRun.getTime() <= now.getTime();
+    } catch {
+      return false;
+    }
+  }
+
+  private buildDefaultInputPayload(inputs: Record<string, any>): Record<string, any> {
+    return Object.entries(inputs).reduce<Record<string, any>>((acc, [key, value]) => {
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        acc[key] = value.default;
+      } else {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  }
+}

package/src/services/workflow-execution-artifact.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowExecutionArtifact } from '../entities/workflow-execution-artifact.entity';
+import { WorkflowExecutionArtifactRepository } from '../repository/workflow-execution-artifact.repository';
+
+@Injectable()
+export class WorkflowExecutionArtifactService extends CRUDService<WorkflowExecutionArtifact>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowExecutionArtifactRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'workflowExecutionArtifact', 'solid-core', moduleRef);
+ }
+}

package/src/services/workflow-execution-log.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowExecutionLog } from '../entities/workflow-execution-log.entity';
+import { WorkflowExecutionLogRepository } from '../repository/workflow-execution-log.repository';
+
+@Injectable()
+export class WorkflowExecutionLogService extends CRUDService<WorkflowExecutionLog>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowExecutionLogRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'workflowExecutionLog', 'solid-core', moduleRef);
+ }
+}

package/src/services/workflow-execution.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowExecution } from '../entities/workflow-execution.entity';
+import { WorkflowExecutionRepository } from '../repository/workflow-execution.repository';
+
+@Injectable()
+export class WorkflowExecutionService extends CRUDService<WorkflowExecution>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowExecutionRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'workflowExecution', 'solid-core', moduleRef);
+ }
+}

package/src/services/workflow-secret.service.ts

@@ -0,0 +1,161 @@
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowSecret } from '../entities/workflow-secret.entity';
+import { WorkflowSecretRepository } from '../repository/workflow-secret.repository';
+import { EncryptionService } from './encryption.service';
+
+const MASKED_SECRET_VALUE = "********";
+
+@Injectable()
+export class WorkflowSecretService extends CRUDService<WorkflowSecret> {
+  private readonly logger = new Logger(WorkflowSecretService.name);
+  private readonly encryptionService: EncryptionService | null;
+
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowSecretRepository,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'workflowSecret', 'solid-core', moduleRef);
+    const encKey = process.env.APP_ENCRYPTION_KEY;
+    this.encryptionService = encKey ? new EncryptionService(encKey) : null;
+    if (!encKey) {
+      this.logger.warn('APP_ENCRYPTION_KEY is not set — workflow secrets cannot be encrypted or decrypted');
+    }
+  }
+
+  async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<WorkflowSecret> {
+    const preparedDto = this.prepareSecretForSave(createDto, true);
+    const saved = await super.create(preparedDto, files, solidRequestContext);
+    return this.maskSecret(saved);
+  }
+
+  async update(
+    id: number,
+    updateDto: any,
+    files: Express.Multer.File[] = [],
+    isPartialUpdate = false,
+    solidRequestContext: any = {},
+    isUpdate = false,
+  ): Promise<WorkflowSecret> {
+    const preparedDto = this.prepareSecretForSave(updateDto, false);
+    const saved = await super.update(id, preparedDto, files, isPartialUpdate, solidRequestContext, isUpdate);
+    return this.maskSecret(saved);
+  }
+
+  async createMany(createDtos: any[], solidRequestContext: any = {}): Promise<WorkflowSecret[]> {
+    const preparedDtos = createDtos.map((dto) => this.prepareSecretForSave(dto, true));
+    const saved = await super.createMany(preparedDtos, solidRequestContext);
+    return saved.map((secret) => this.maskSecret(secret));
+  }
+
+  async find(basicFilterDto: any, solidRequestContext: any = {}): Promise<any> {
+    const response = await super.find(basicFilterDto, solidRequestContext);
+    return {
+      ...response,
+      records: (response.records ?? []).map((secret: WorkflowSecret) => this.maskSecret(secret)),
+    };
+  }
+
+  async findOne(id: number, query: any = {}, solidRequestContext: any = {}) {
+    const secret = await super.findOne(id, query, solidRequestContext);
+    return this.maskSecret(secret);
+  }
+
+  async getWorkflowSecretsContext(): Promise<Record<string, any>> {
+    const secrets = await this.repo.find({
+      where: { status: "active" } as any,
+    });
+
+    const context: Record<string, any> = {};
+    for (const secret of secrets) {
+      try {
+        this.assignSecretPath(context, secret.key, this.decryptAndCoerce(secret));
+        secret.lastAccessedAt = new Date();
+      } catch (error) {
+        this.logger.warn(`Failed to resolve workflow secret "${secret.key}": ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+
+    if (secrets.length > 0) {
+      await this.repo.save(secrets);
+    }
+
+    return context;
+  }
+
+  private prepareSecretForSave(dto: any, requireValue: boolean): any {
+    const preparedDto = { ...dto };
+    const rawValue = preparedDto.value;
+    const hasNewValue = rawValue !== undefined && rawValue !== null && rawValue !== MASKED_SECRET_VALUE;
+
+    if (requireValue && !hasNewValue) {
+      throw new BadRequestException('Workflow secret value is required.');
+    }
+
+    if (hasNewValue) {
+      preparedDto.value = this.encrypt(String(rawValue));
+      preparedDto.lastRotatedAt = new Date();
+    } else {
+      delete preparedDto.value;
+    }
+
+    return preparedDto;
+  }
+
+  private encrypt(value: string): string {
+    if (!this.encryptionService) {
+      throw new BadRequestException('APP_ENCRYPTION_KEY must be set before workflow secrets can be saved.');
+    }
+
+    return this.encryptionService.isEncrypted(value) ? value : this.encryptionService.encrypt(value);
+  }
+
+  private decryptAndCoerce(secret: WorkflowSecret): any {
+    if (!this.encryptionService) {
+      throw new BadRequestException('APP_ENCRYPTION_KEY must be set before workflow secrets can be used.');
+    }
+
+    const decryptedValue = this.encryptionService.decrypt(secret.value);
+    switch (secret.valueType) {
+      case 'json':
+        return JSON.parse(decryptedValue);
+      case 'number':
+        return Number(decryptedValue);
+      case 'boolean':
+        return decryptedValue === 'true' || decryptedValue === '1';
+      case 'string':
+      default:
+        return decryptedValue;
+    }
+  }
+
+  private assignSecretPath(target: Record<string, any>, key: string, value: any): void {
+    const parts = String(key)
+      .split('.')
+      .map((part) => part.trim())
+      .filter(Boolean);
+
+    if (parts.length === 0) {
+      return;
+    }
+
+    let cursor = target;
+    parts.slice(0, -1).forEach((part) => {
+      cursor[part] = cursor[part] && typeof cursor[part] === 'object' ? cursor[part] : {};
+      cursor = cursor[part];
+    });
+    cursor[parts[parts.length - 1]] = value;
+  }
+
+  private maskSecret(secret: WorkflowSecret): WorkflowSecret {
+    if (secret) {
+      secret.value = MASKED_SECRET_VALUE;
+    }
+    return secret;
+  }
+}

package/src/services/workflow-step-execution.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowStepExecution } from '../entities/workflow-step-execution.entity';
+import { WorkflowStepExecutionRepository } from '../repository/workflow-step-execution.repository';
+
+@Injectable()
+export class WorkflowStepExecutionService extends CRUDService<WorkflowStepExecution>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowStepExecutionRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'workflowStepExecution', 'solid-core', moduleRef);
+ }
+}

package/src/services/workflow-trigger-execution.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { WorkflowTriggerExecution } from '../entities/workflow-trigger-execution.entity';
+import { WorkflowTriggerExecutionRepository } from '../repository/workflow-trigger-execution.repository';
+
+@Injectable()
+export class WorkflowTriggerExecutionService extends CRUDService<WorkflowTriggerExecution>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: WorkflowTriggerExecutionRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'workflowTriggerExecution', 'solid-core', moduleRef);
+ }
+}