@solidxai/core 0.1.12 → 0.1.13-beta.10

package/src/entities/workflow-execution-log.entity.ts

@@ -0,0 +1,58 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { WorkflowExecution } from './workflow-execution.entity';
+import { WorkflowStepExecution } from './workflow-step-execution.entity'
+
+@Entity('ss_workflow_execution_log')
+export class WorkflowExecutionLog extends CommonEntity {
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    logKey: string;
+
+    @Index()
+    @ManyToOne(() => WorkflowExecution, { onDelete: "CASCADE", nullable: false })
+    @JoinColumn()
+    workflowExecution: WorkflowExecution;
+
+    @Index()
+    @ManyToOne(() => WorkflowStepExecution, { onDelete: "CASCADE", nullable: true })
+    @JoinColumn()
+    workflowStepExecution: WorkflowStepExecution;
+
+    @Index()
+    @Column({ type: "varchar", default: "info" })
+    level: string = "info";
+
+    @Column({ type: "text" })
+    message: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    eventType: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    source: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    nodeId: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    nodeType: string;
+
+    @Index()
+    @Column({ type: "integer", nullable: true })
+    sequenceNumber: number;
+
+    @Index()
+    @Column({ type: "timestamp" })
+    occurredAt: Date;
+
+    @Column({ type: "simple-json", nullable: true })
+    context: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    metadata: any;
+}

package/src/entities/workflow-execution.entity.ts

@@ -0,0 +1,82 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Entity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { WorkflowDefinition } from './workflow-definition.entity'
+import { WorkflowStepExecution } from './workflow-step-execution.entity';
+import { WorkflowExecutionLog } from './workflow-execution-log.entity';
+import { WorkflowExecutionArtifact } from './workflow-execution-artifact.entity';
+
+@Entity('ss_workflow_execution')
+export class WorkflowExecution extends CommonEntity {
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    executionIdentifier: string;
+
+    @Index()
+    @ManyToOne(() => WorkflowDefinition, { onDelete: "CASCADE", nullable: false })
+    @JoinColumn()
+    workflowDefinition: WorkflowDefinition;
+
+    @Index()
+    @Column({ type: "varchar" })
+    workflowKey: string;
+
+    @Column({ type: "varchar", nullable: true })
+    workflowDisplayName: string;
+
+    @Index()
+    @Column({ type: "varchar", default: "created" })
+    status: string = "created";
+
+    @Index()
+    @Column({ type: "varchar", default: "manual" })
+    triggerType: string = "manual";
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    startedAt: Date;
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    finishedAt: Date;
+
+    @Column({ type: "bigint", nullable: true })
+    durationMs: bigint;
+
+    @Column({ type: "simple-json", nullable: true })
+    inputPayload: any;
+
+    // Retained for schema/backward compatibility only. Combined workflow output
+    // is no longer persisted here because large loops can make this payload
+    // duplicate all step outputs and cause OOMs; use step execution outputs.
+    @Column({ type: "simple-json", nullable: true })
+    outputPayload: any;
+
+    @Column({ type: "varchar", nullable: true })
+    definitionVersion: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    definitionChecksum: string;
+
+    @Column({ name: "definition_snapshot", type: "text", nullable: true})
+    definitionSnapshot: string;
+
+    @Column({ type: "text", nullable: true })
+    errorSummary: string;
+
+    @Column({ type: "simple-json", nullable: true })
+    errorDetails: any;
+
+    @Index()
+    @Column({ type: "bigint", nullable: true })
+    requestedByUserId: bigint;
+
+    @OneToMany(() => WorkflowStepExecution, workflowStepExecution => workflowStepExecution.workflowExecution, { cascade: true })
+    workflowStepExecutions: WorkflowStepExecution[];
+
+    @OneToMany(() => WorkflowExecutionLog, workflowExecutionLog => workflowExecutionLog.workflowExecution, { cascade: true })
+    workflowExecutionLogs: WorkflowExecutionLog[];
+
+    @OneToMany(() => WorkflowExecutionArtifact, workflowExecutionArtifact => workflowExecutionArtifact.workflowExecution, { cascade: true })
+    workflowExecutionArtifacts: WorkflowExecutionArtifact[];
+}

package/src/entities/workflow-secret.entity.ts

@@ -0,0 +1,33 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Entity, Column, Index } from 'typeorm';
+
+@Entity('ss_workflow_secret')
+export class WorkflowSecret extends CommonEntity {
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    key: string;
+
+    @Index()
+    @Column({ type: "varchar" })
+    displayName: string;
+
+    @Column({ type: "text", nullable: true })
+    description: string;
+
+    @Column({ type: "text" })
+    value: string;
+
+    @Index()
+    @Column({ type: "varchar", default: "string" })
+    valueType: string = "string";
+
+    @Index()
+    @Column({ type: "varchar", default: "active" })
+    status: string = "active";
+
+    @Column({ type: "timestamp", nullable: true })
+    lastRotatedAt: Date;
+
+    @Column({ type: "timestamp", nullable: true })
+    lastAccessedAt: Date;
+}

package/src/entities/workflow-step-execution.entity.ts

@@ -0,0 +1,88 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { WorkflowExecution } from './workflow-execution.entity'
+
+@Entity('ss_workflow_step_execution')
+export class WorkflowStepExecution extends CommonEntity {
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    stepExecutionKey: string;
+
+    @Index()
+    @ManyToOne(() => WorkflowExecution, { onDelete: "CASCADE", nullable: false })
+    @JoinColumn()
+    workflowExecution: WorkflowExecution;
+
+    @Index()
+    @Column({ type: "varchar" })
+    nodeId: string;
+
+    @Column({ type: "varchar", nullable: true })
+    nodeName: string;
+
+    @Index()
+    @Column({ type: "varchar", default: "task" })
+    nodeKind: string = "task";
+
+    @Index()
+    @Column({ type: "varchar" })
+    nodeType: string;
+
+    @Index()
+    @Column({ type: "varchar", default: "created" })
+    status: string = "created";
+
+    @Index()
+    @Column({ type: "integer", default: 1 })
+    attemptNumber: number = 1;
+
+    @Column({ type: "integer", nullable: true, default: 0 })
+    retryCount: number = 0;
+
+    @Column({ type: "integer", nullable: true })
+    maxRetries: number;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    parentNodeId: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    parentStepExecutionKey: string;
+
+    @Index()
+    @Column({ type: "integer", nullable: true })
+    sequenceNumber: number;
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    startedAt: Date;
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    finishedAt: Date;
+
+    @Column({ type: "bigint", nullable: true })
+    durationMs: bigint;
+
+    @Column({ type: "bigint", nullable: true })
+    timeoutMs: bigint;
+
+    @Column({ type: "simple-json", nullable: true })
+    inputPayload: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    outputPayload: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    runtimeContext: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    nodeSnapshot: any;
+
+    @Column({ type: "text", nullable: true })
+    errorSummary: string;
+
+    @Column({ type: "simple-json", nullable: true })
+    errorDetails: any;
+}

package/src/entities/workflow-trigger-execution.entity.ts

@@ -0,0 +1,82 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { WorkflowDefinition } from './workflow-definition.entity';
+import { WorkflowExecution } from './workflow-execution.entity'
+
+@Entity('ss_workflow_trigger_execution')
+export class WorkflowTriggerExecution extends CommonEntity {
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    triggerExecutionKey: string;
+
+    @Index()
+    @ManyToOne(() => WorkflowDefinition, { onDelete: "CASCADE", nullable: false })
+    @JoinColumn()
+    workflowDefinition: WorkflowDefinition;
+
+    @Index()
+    @ManyToOne(() => WorkflowExecution, { onDelete: "CASCADE", nullable: true })
+    @JoinColumn()
+    workflowExecution: WorkflowExecution;
+
+    @Index()
+    @Column({ type: "varchar" })
+    triggerId: string;
+
+    @Column({ type: "varchar", nullable: true })
+    triggerName: string;
+
+    @Index()
+    @Column({ type: "varchar" })
+    triggerType: string;
+
+    @Index()
+    @Column({ type: "varchar", default: "received" })
+    status: string = "received";
+
+    @Index()
+    @Column({ nullable: true, default: false })
+    matched: boolean = false;
+
+    @Index()
+    @Column({ type: "timestamp" })
+    firedAt: Date;
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    startedAt: Date;
+
+    @Index()
+    @Column({ type: "timestamp", nullable: true })
+    finishedAt: Date;
+
+    @Column({ type: "bigint", nullable: true })
+    durationMs: bigint;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    source: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    correlationId: string;
+
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    idempotencyKey: string;
+
+    @Column({ type: "simple-json", nullable: true })
+    payload: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    triggerSnapshot: any;
+
+    @Column({ type: "text", nullable: true })
+    errorSummary: string;
+
+    @Column({ type: "simple-json", nullable: true })
+    errorDetails: any;
+
+    @Column({ type: "simple-json", nullable: true })
+    metadata: any;
+}

package/src/factories/mail.factory.ts

@@ -30,8 +30,14 @@ export class MailFactory {
         }
 
         const mailServiceProvider = mailProviders.find(provider => provider.name === mailServiceName);
+        if (!mailServiceProvider?.instance) {
+            const registeredProviders = mailProviders.map((provider) => provider?.name).filter(Boolean).join(", ");
+            throw new Error(
+                `Mail provider "${mailServiceName}" is not registered. Registered providers: ${registeredProviders || "none"}`,
+            );
+        }
 
         return mailServiceProvider.instance as IMail;
     }
 
-}
+}

package/src/factories/sms.factory.ts

@@ -25,7 +25,7 @@ export class SmsFactory {
     getSmsService(name: string = null): ISMS {
         // This is the default provider
         // const smsServiceName = name || this.commonConfiguration.smsProvider;
-        const smsServiceName = this.settingService.getConfigValue<SolidCoreSetting>('smsProvider');
+        const smsServiceName = name || this.settingService.getConfigValue<SolidCoreSetting>('smsProvider');
         if (!smsServiceName) {
             throw new Error("Unable to resolve sms provider")
         }
@@ -38,6 +38,9 @@ export class SmsFactory {
         }
 
         const smsServiceProvider = smsProviders.find(provider => provider.name === smsServiceName);
+        if (!smsServiceProvider) {
+            throw new Error(`Unable to resolve sms provider ${smsServiceName}`);
+        }
 
         return smsServiceProvider.instance as ISMS;
     }

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

@@ -1,5 +1,5 @@
 import { FieldCrudManager, ValidationError } from "src/interfaces";
-import { DANGEROUS_EXTENSIONS, EXT_TO_MEDIA_TYPE, MediaCategory } from "src/constants/media-file-types";
+import { EXT_TO_MEDIA_TYPE, getLowercaseFileExtension, getUploadedFileName, isDangerousMediaFile, MediaCategory } from "src/constants/media-file-types";
 
 export enum SolidMediaType {
     mediaSingle = 'mediaSingle',
@@ -79,16 +79,15 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     constructor(private readonly options: MediaFieldOptions) {
     }
 
-    private resolveMediaType(mimetype?: string, filename?: string): MediaType | null {
-        const ext = (filename || '').split('.').pop()?.toLowerCase();
-        if (ext && DANGEROUS_EXTENSIONS.has(ext)) {
+    private resolveMediaType(file: Express.Multer.File): MediaType | null {
+        // Belt-and-braces: dangerous files are already rejected outright by
+        // validateDangerousFiles, but never let one resolve to a usable category.
+        if (isDangerousMediaFile(file)) {
             return null;
         }
 
-        const mt = (mimetype || '').toLowerCase().trim();
-        if (mt === 'image/svg+xml' || mt === 'text/html' || mt === 'application/xhtml+xml') {
-            return null;
-        }
+        const ext = getLowercaseFileExtension(getUploadedFileName(file));
+        const mt = (file.mimetype || '').toLowerCase().trim();
         if (mt && MIME_TO_MEDIA_TYPE[mt]) {
             return MIME_TO_MEDIA_TYPE[mt];
         }
@@ -113,16 +112,31 @@ export class MediaFieldCrudManager implements FieldCrudManager {
     }
 
     private applyValidations(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
+        // Runs for every media field type and regardless of the admin-configured mediaTypes
+        // allowlist - a dangerous upload is never acceptable, so this must not sit behind
+        // the optional type checks below.
+        const errors = this.validateDangerousFiles(fieldFiles);
+
         switch (this.options.type) {
             case SolidMediaType.mediaSingle:
-                return this.validateMediaSingle(fieldFiles);
+                return [...errors, ...this.validateMediaSingle(fieldFiles)];
             case SolidMediaType.mediaMultiple:
-                return this.validateMediaMultiple(fieldFiles);
+                return [...errors, ...this.validateMediaMultiple(fieldFiles)];
             default:
-                return [];
+                return errors;
         }
     }
 
+    private validateDangerousFiles(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
+        return fieldFiles
+            .filter(fieldFile => isDangerousMediaFile(fieldFile))
+            .map(fieldFile => ({
+                field: this.options.fieldName,
+                error: `${this.options.fieldName} file type not allowed. ` +
+                    `${getUploadedFileName(fieldFile) || 'File'} is a potentially dangerous file type.`
+            }));
+    }
+
     private validateMediaSingle(fieldFiles: Array<Express.Multer.File>): ValidationError[] {
         const errors: ValidationError[] = [];
         if (!this.options.isUpdate && this.options.required && fieldFiles.length === 0) {
@@ -157,7 +171,7 @@ export class MediaFieldCrudManager implements FieldCrudManager {
             for (let i = 0; i < fieldFiles.length; i++) {
                 const fieldFile = fieldFiles[i];
 
-                const resolvedType = this.resolveMediaType(fieldFile.mimetype, fieldFile.originalname ?? fieldFile.filename ?? '');
+                const resolvedType = this.resolveMediaType(fieldFile);
                 if (!resolvedType || !allowedFileTypes.includes(resolvedType)) {
                     errors.push({
                         field: this.options.fieldName,

package/src/helpers/file-download.helper.ts

@@ -0,0 +1,31 @@
+import type { Response } from "express";
+
+export interface FileDownloadHeaderOptions {
+  fileName: string;
+  mimeType: string;
+  /** Defaults to 'attachment'; only pass 'inline' for types known safe to render. */
+  disposition?: "inline" | "attachment";
+  /** Opt in for assets loaded cross-origin by the UI (e.g. media served to :3000). */
+  crossOriginResourcePolicy?: boolean;
+}
+
+/**
+ * Single place that stamps the response headers for every streamed file download, so the
+ * security headers can't be applied to one endpoint and forgotten on the next.
+ */
+export function setFileDownloadHeaders(res: Response, options: FileDownloadHeaderOptions): void {
+  const disposition = options.disposition ?? "attachment";
+
+  res.setHeader("Content-Disposition", `${disposition}; filename="${options.fileName}"`);
+  res.setHeader("Content-Type", options.mimeType);
+  res.setHeader("Access-Control-Expose-Headers", "Content-Disposition, Content-Type");
+
+  // Prevent the browser from ever content-sniffing a served file into something more
+  // dangerous than its declared Content-Type (e.g. rendering a mislabeled upload as HTML
+  // and executing embedded script).
+  res.setHeader("X-Content-Type-Options", "nosniff");
+
+  if (options.crossOriginResourcePolicy) {
+    res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+  }
+}

package/src/helpers/model-metadata-helper.service.ts

@@ -2,6 +2,7 @@
 
 import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
 import { _ } from "lodash";
+import { DRAFT_PUBLISH_VERSIONING_FIELD_NAMES } from "src/constants/draft-publish-fields";
 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 { ModelMetadataRepository } from "src/repository/model-metadata.repository";
@@ -87,6 +88,32 @@ export class ModelMetadataHelperService {
                 isSystem: true,
                 enableAuditTracking:true
             },
+            {
+                name: "isPublished",
+                displayName: "Is Published",
+                type: "boolean",
+                isSystem: true,
+                enableAuditTracking: true
+            },
+            {
+                name: "isLatest",
+                displayName: "Is Latest",
+                type: "boolean",
+                isSystem: true,
+                enableAuditTracking: true
+            },
+            {
+                name: "initialEntityVersionId",
+                displayName: "Initial Entity Version Id",
+                type: "int",
+                isSystem: true,
+            },
+            {
+                name: "publishedTracker",
+                displayName: "Published Tracker",
+                type: "shortText",
+                isSystem: true,
+            },
             {
                 name: "localeName",
                 displayName: "Locale",
@@ -117,7 +144,11 @@ export class ModelMetadataHelperService {
     }
 
     private getSystemFieldsMetadataMappingForLegacyTable(withId: boolean=true) {
-        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        // Legacy tables don't have the draft/publish versioning columns, so exclude
+        // them from the legacy system fields metadata mapping.
+        const legacyExcludedFieldNames: readonly string[] = DRAFT_PUBLISH_VERSIONING_FIELD_NAMES;
+        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping()
+            .filter(field => !legacyExcludedFieldNames.includes(field.name));
         if (!withId) {
             // Remove the id field metadata
             const index = systemFieldsMetadata.findIndex(field => field.name === 'id');

package/src/helpers/solid-registry.ts

@@ -7,7 +7,7 @@ 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 { IDashboardWidgetDataProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
+import { IDashboardWidgetDataProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule, IWorkflowFieldDataProvider } from "../interfaces";
 import { ObjectLiteral } from 'typeorm';
 
 type ControllerMetadata = {
@@ -71,6 +71,7 @@ export class SolidRegistry {
   private seeders: Set<InstanceWrapper> = new Set();
   private scheduledJobProviders: Set<InstanceWrapper> = new Set();
   private selectionProviders: Set<InstanceWrapper> = new Set();
+  private workflowFieldDataProviders: Set<InstanceWrapper> = new Set();
   private dashboardWidgetDataProviders: Set<InstanceWrapper> = new Set();
   private computedFieldProviders: Set<InstanceWrapper> = new Set();
   private solidDatabaseModules: Set<InstanceWrapper> = new Set();
@@ -137,6 +138,10 @@ export class SolidRegistry {
     this.selectionProviders.add(selectionProvider);
   }
 
+  registerWorkflowFieldDataProvider(provider: InstanceWrapper): void {
+    this.workflowFieldDataProviders.add(provider);
+  }
+
   registerDashboardWidgetDataProvider(provider: InstanceWrapper): void {
     this.dashboardWidgetDataProviders.add(provider);
   }
@@ -227,6 +232,10 @@ export class SolidRegistry {
     return Array.from(this.selectionProviders);
   }
 
+  getWorkflowFieldDataProviders(): Array<InstanceWrapper> {
+    return Array.from(this.workflowFieldDataProviders);
+  }
+
   getDashboardWidgetDataProviders(): Array<InstanceWrapper> {
     return Array.from(this.dashboardWidgetDataProviders);
   }
@@ -242,6 +251,17 @@ export class SolidRegistry {
     }
   }
 
+  getWorkflowFieldDataProviderInstance(name: string): IWorkflowFieldDataProvider | undefined {
+    const providers = this.getWorkflowFieldDataProviders();
+    for (let i = 0; i < providers.length; i++) {
+      const provider = providers[i];
+      if (provider?.instance?.name?.() === name || provider?.name === name) {
+        return provider.instance as IWorkflowFieldDataProvider;
+      }
+    }
+    return undefined;
+  }
+
   getDashboardWidgetDataProviderInstance(name: string): IDashboardWidgetDataProvider | undefined {
     const providers = this.getDashboardWidgetDataProviders();
     for (let i = 0; i < providers.length; i++) {
@@ -346,7 +366,7 @@ export class SolidRegistry {
   }
 
   getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
-    return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
+    return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt', 'isPublished', 'isLatest', 'initialEntityVersionId', 'publishedTracker'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
   }