@solidxai/core 0.1.12 → 0.1.13-beta.10

package/src/index.ts

@@ -29,6 +29,8 @@ export * from './decorators/security-rule-config-provider.decorator'
 export * from './decorators/sms-provider.decorator'
 export * from './decorators/settings-provider.decorator'
 export * from './decorators/extension-user-creation-provider.decorator'
+export * from './decorators/workflow-node-provider.decorator'
+export * from './decorators/workflow-field-data-provider.decorator'
 
 export * from './dtos/post-chatter-message.dto'
 export * from './dtos/update-chatter-note-message.dto'
@@ -117,6 +119,22 @@ export * from './dtos/metadata-explorer-search-query.dto'
 export * from './dtos/metadata-explorer-write.dto'
 export * from './dtos/create-dashboard-user-layout.dto'
 export * from './dtos/update-dashboard-user-layout.dto'
+export * from './dtos/create-workflow-definition.dto'
+export * from './dtos/update-workflow-definition.dto'
+export * from './dtos/create-workflow-execution.dto'
+export * from './dtos/update-workflow-execution.dto'
+export * from './dtos/create-workflow-step-execution.dto'
+export * from './dtos/update-workflow-step-execution.dto'
+export * from './dtos/create-workflow-execution-log.dto'
+export * from './dtos/update-workflow-execution-log.dto'
+export * from './dtos/create-workflow-execution-artifact.dto'
+export * from './dtos/update-workflow-execution-artifact.dto'
+export * from './dtos/create-workflow-trigger-execution.dto'
+export * from './dtos/update-workflow-trigger-execution.dto'
+export * from './dtos/create-workflow-secret.dto'
+export * from './dtos/update-workflow-secret.dto'
+export * from './dtos/execute-workflow.dto'
+export * from './dtos/validate-workflow-definition.dto'
 
 export * from './entities/action-metadata.entity'
 export * from './entities/common.entity'
@@ -159,6 +177,13 @@ export * from './entities/user-activity-history.entity'
 export * from './entities/model-sequence.entity'
 export * from './entities/dashboard-user-layout.entity'
 export * from './entities/user-api-key.entity'
+export * from './entities/workflow-definition.entity'
+export * from './entities/workflow-execution.entity'
+export * from './entities/workflow-step-execution.entity'
+export * from './entities/workflow-execution-log.entity'
+export * from './entities/workflow-execution-artifact.entity'
+export * from './entities/workflow-trigger-execution.entity'
+export * from './entities/workflow-secret.entity'
 
 export * from './enums/auth-type.enum'
 export * from './enums/legacy-table-type.enum'
@@ -200,6 +225,7 @@ export * from './helpers/environment.helper'
 export * from './helpers/cache.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
+export * from './helpers/file-download.helper'
 export * from './helpers/model-metadata-helper.service'
 export * from './helpers/image-encoding.helper'
 export * from './helpers/solid-microservice-adapter.service'
@@ -212,9 +238,31 @@ export * from './interceptors/wrap-response.interceptor'
 
 export * from './interfaces/active-user-data.interface'
 export * from './interfaces/mq'
+export * from './interfaces/workflow-node-handler.interface'
+export * from './types/workflow-dsl.types'
 export * from './services/scheduled-jobs/scheduled-job.interface';
 export * from './services/scheduled-jobs/scheduler.interface';
 export * from './services/scheduled-jobs/scheduler.service';
+export * from './services/workflow/workflow-definition-validator.service'
+export * from './services/workflow/workflow-execution-writer.service'
+export * from './services/workflow/workflow-expression.service'
+export * from './services/workflow/workflow-invocation.service'
+export * from './services/workflow/workflow-node-registry.service'
+export * from './services/workflow/workflow-runtime.service'
+export * from './services/workflow/nodes/execution-fail.node'
+export * from './services/workflow/nodes/for-each.node'
+export * from './services/workflow/nodes/http-request.node'
+export * from './services/workflow/nodes/if.node'
+export * from './services/workflow/nodes/log-write.node'
+export * from './services/workflow/nodes/loop-until.node'
+export * from './services/workflow/nodes/parallel.node'
+export * from './services/workflow/nodes/sequential.node'
+export * from './services/workflow/nodes/solidx-crud.nodes'
+export * from './services/workflow/nodes/solidx-login.node'
+export * from './services/workflow/nodes/solidx-send-email.node'
+export * from './services/workflow/nodes/solidx-send-sms.node'
+export * from './services/workflow/nodes/switch.node'
+export * from './types/workflow-execution-queue.types'
 
 export * from './jobs/rabbitmq/api-email-publisher.service'
 export * from './jobs/rabbitmq/api-email-queue-options'
@@ -231,6 +279,9 @@ export * from './jobs/rabbitmq/msg91-sms-subscriber.service'
 export * from './jobs/rabbitmq/msg91-whatsapp-publisher.service'
 export * from './jobs/rabbitmq/msg91-whatsapp-queue-options'
 export * from './jobs/rabbitmq/msg91-whatsapp-subscriber.service'
+export * from './jobs/rabbitmq/workflow-execution-publisher.service'
+export * from './jobs/rabbitmq/workflow-execution-queue-options'
+export * from './jobs/rabbitmq/workflow-execution-subscriber.service'
 
 export * from './jobs/redis/api-email-publisher-redis.service'
 export * from './jobs/redis/api-email-queue-options-redis'
@@ -244,6 +295,9 @@ export * from './jobs/redis/computed-field-evaluation-subscriber-redis.service'
 export * from './jobs/redis/generate-code-publisher-redis.service'
 export * from './jobs/redis/generate-code-queue-options-redis'
 export * from './jobs/redis/generate-code-subscriber-redis.service'
+export * from './jobs/redis/workflow-execution-publisher-redis.service'
+export * from './jobs/redis/workflow-execution-queue-options-redis'
+export * from './jobs/redis/workflow-execution-subscriber-redis.service'
 export * from './jobs/redis/msg91-otp-publisher-redis.service'
 export * from './jobs/redis/msg91-otp-queue-options-redis'
 export * from './jobs/redis/msg91-otp-subscriber-redis.service'
@@ -284,6 +338,7 @@ export * from './services/action-metadata.service'
 export * from './services/authentication.service'
 export * from './services/bcrypt.service'
 export * from './services/computed-fields/uuid-external-id-computed-field-provider.service'
+export * from './services/draft-publish-helper.service'
 export * from './services/crud-helper.service'
 export * from './services/crud.service'
 export * from './services/email-template.service'
@@ -358,6 +413,9 @@ export * from './services/dashboard-runtime.service'
 export * from './services/queues/publisher-factory.service'
 export * from './services/queues/database-publisher.service'
 export * from './services/queues/database-subscriber.service'
+export * from './jobs/database/workflow-execution-publisher-database.service'
+export * from './jobs/database/workflow-execution-queue-options-database'
+export * from './jobs/database/workflow-execution-subscriber-database.service'
 export * from './services/dashboard-providers/mq-dashboard-total-messages-kpi-provider.service'
 export * from './services/dashboard-providers/mq-dashboard-succeeded-messages-kpi-provider.service'
 export * from './services/dashboard-providers/mq-dashboard-failed-messages-kpi-provider.service'
@@ -393,6 +451,7 @@ export * from './subscribers/audit.subscriber'
 
 export * from './transformers/array-transformer'
 export * from './transformers/boolean-transformer'
+export * from './transformers/empty-string-to-null-transformer'
 export * from './transformers/integer-transformer'
 export { default as datetimeTransformer } from './transformers/datetime-transformer'
 export * from './transformers/typeorm/local-date-time-transformer'

package/src/interfaces/workflow-node-handler.interface.ts

@@ -0,0 +1,10 @@
+import {
+  WorkflowNodeExecutionContext,
+  WorkflowNodeHandlerResult,
+} from '../types/workflow-dsl.types';
+
+export interface WorkflowNodeHandler {
+  execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult>;
+}

package/src/interfaces.ts

@@ -16,6 +16,8 @@ import { ComputedFieldMetadata } from './helpers/solid-registry';
 import { ActiveUserData } from './interfaces/active-user-data.interface';
 import { SecurityRuleConfig } from './dtos/security-rule-config.dto';
 import { SecurityRule } from './entities/security-rule.entity';
+import { ModelMetadata } from './entities/model-metadata.entity';
+import { ViewMetadata } from './entities/view-metadata.entity';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -159,6 +161,33 @@ export interface ISelectionProvider<T extends ISelectionProviderContext> {
   values(query: any, ctxt: T): Promise<readonly ISelectionProviderValues[]>;
 }
 
+export interface IWorkflowFieldDataProviderContext<TProviderContext = Record<string, any>> {
+  entityId?: string;
+  modelName: string;
+  moduleName: string;
+  workflowFieldName: string;
+  workflowField: FieldMetadata;
+  solidModel?: ModelMetadata;
+  solidView?: ViewMetadata;
+  solidFieldsMetadata: Record<string, FieldMetadata>;
+  query?: Record<string, any>;
+  providerContext: TProviderContext;
+  activeUser?: ActiveUserData;
+}
+
+export interface IWorkflowFieldDataProviderValues {
+  label: string;
+  value: string | number;
+}
+
+export interface IWorkflowFieldDataProvider<
+  TContext extends IWorkflowFieldDataProviderContext = IWorkflowFieldDataProviderContext,
+> {
+  help(): string;
+  name(): string;
+  values(ctxt: TContext): Promise<readonly IWorkflowFieldDataProviderValues[]>;
+}
+
 export interface IDashboardWidgetDataProviderContext<TVariables = Record<string, any>, TProviderContext = Record<string, any>> {
   moduleName: string;
   dashboardName: string;
@@ -243,6 +272,7 @@ export interface ModuleMetadataSeederOptions {
   modulesToSeed: string[] | null;
   pruneMetadata: boolean;
   seedGlobalMetadata: boolean;
+  skipHooks: boolean;
 }
 
 export interface ModuleMetadataSeederEventPayload {

package/src/jobs/database/workflow-execution-publisher-database.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { DatabasePublisher } from '../../services/queues/database-publisher.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options-database';
+
+@Injectable()
+export class WorkflowExecutionPublisherDatabase extends DatabasePublisher<WorkflowExecutionQueuePayload> {
+  constructor(
+    protected readonly mqMessageService: MqMessageService,
+    protected readonly mqMessageQueueService: MqMessageQueueService,
+  ) {
+    super(mqMessageService, mqMessageQueueService);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+}

package/src/jobs/database/workflow-execution-queue-options-database.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from '../../interfaces';
+
+const QUEUE_NAME = 'solid_workflow_execution_queue_database';
+
+export default {
+  name: QUEUE_NAME,
+  type: BrokerType.Database,
+  queueName: QUEUE_NAME,
+};

package/src/jobs/database/workflow-execution-subscriber-database.service.ts

@@ -0,0 +1,44 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from '../../interfaces/mq';
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { PollerService } from '../../services/poller.service';
+import { DatabaseSubscriber } from '../../services/queues/database-subscriber.service';
+import { WorkflowRuntimeService } from '../../services/workflow/workflow-runtime.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options-database';
+
+@Injectable()
+export class WorkflowExecutionSubscriberDatabase extends DatabaseSubscriber<WorkflowExecutionQueuePayload> {
+  private readonly workflowExecutionLogger = new Logger(WorkflowExecutionSubscriberDatabase.name);
+
+  constructor(
+    readonly mqMessageService: MqMessageService,
+    readonly mqMessageQueueService: MqMessageQueueService,
+    readonly poller: PollerService,
+    private readonly workflowRuntimeService: WorkflowRuntimeService,
+  ) {
+    super(mqMessageService, mqMessageQueueService, poller);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+
+  async subscribe(message: QueueMessage<WorkflowExecutionQueuePayload>) {
+    const payload = message.payload;
+    this.workflowExecutionLogger.log(
+      `Processing queued workflow execution message ${message.messageId ?? '<unknown>'}.`,
+    );
+
+    if (payload.executionId !== undefined && payload.executionId !== null) {
+      return this.workflowRuntimeService.executeEnqueuedExecution(payload.executionId);
+    }
+
+    throw new Error('Workflow execution queue payload must include executionId.');
+  }
+}

package/src/jobs/rabbitmq/workflow-execution-publisher.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { RabbitMqPublisher } from '../../services/queues/rabbitmq-publisher.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options';
+
+@Injectable()
+export class WorkflowExecutionPublisherRabbitmq extends RabbitMqPublisher<WorkflowExecutionQueuePayload> {
+  constructor(
+    protected readonly mqMessageService: MqMessageService,
+    protected readonly mqMessageQueueService: MqMessageQueueService,
+  ) {
+    super(mqMessageService, mqMessageQueueService);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+}

package/src/jobs/rabbitmq/workflow-execution-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from '../../interfaces';
+
+const QUEUE_NAME = 'solid_workflow_execution_queue_rabbitmq';
+
+export default {
+  name: QUEUE_NAME,
+  type: BrokerType.RabbitMQ,
+  queueName: QUEUE_NAME,
+};

package/src/jobs/rabbitmq/workflow-execution-subscriber.service.ts

@@ -0,0 +1,42 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from '../../interfaces/mq';
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { RabbitMqSubscriber } from '../../services/queues/rabbitmq-subscriber.service';
+import { WorkflowRuntimeService } from '../../services/workflow/workflow-runtime.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options';
+
+@Injectable()
+export class WorkflowExecutionSubscriberRabbitmq extends RabbitMqSubscriber<WorkflowExecutionQueuePayload> {
+  private readonly workflowExecutionLogger = new Logger(WorkflowExecutionSubscriberRabbitmq.name);
+
+  constructor(
+    readonly mqMessageService: MqMessageService,
+    readonly mqMessageQueueService: MqMessageQueueService,
+    private readonly workflowRuntimeService: WorkflowRuntimeService,
+  ) {
+    super(mqMessageService, mqMessageQueueService);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+
+  async subscribe(message: QueueMessage<WorkflowExecutionQueuePayload>) {
+    const payload = message.payload;
+    this.workflowExecutionLogger.log(
+      `Processing queued workflow execution message ${message.messageId ?? '<unknown>'}.`,
+    );
+
+    if (payload.executionId !== undefined && payload.executionId !== null) {
+      return this.workflowRuntimeService.executeEnqueuedExecution(payload.executionId);
+    }
+
+    throw new Error('Workflow execution queue payload must include executionId.');
+  }
+}

package/src/jobs/redis/workflow-execution-publisher-redis.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { RedisPublisher } from '../../services/queues/redis-publisher.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options-redis';
+
+@Injectable()
+export class WorkflowExecutionPublisherRedis extends RedisPublisher<WorkflowExecutionQueuePayload> {
+  constructor(
+    protected readonly mqMessageService: MqMessageService,
+    protected readonly mqMessageQueueService: MqMessageQueueService,
+  ) {
+    super(mqMessageService, mqMessageQueueService);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+}

package/src/jobs/redis/workflow-execution-queue-options-redis.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from '../../interfaces';
+
+const QUEUE_NAME = 'solid_workflow_execution_queue_redis';
+
+export default {
+  name: QUEUE_NAME,
+  type: BrokerType.Redis,
+  queueName: QUEUE_NAME,
+};

package/src/jobs/redis/workflow-execution-subscriber-redis.service.ts

@@ -0,0 +1,42 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from '../../interfaces/mq';
+import { QueuesModuleOptions } from '../../interfaces';
+import { WorkflowExecutionQueuePayload } from '../../types/workflow-execution-queue.types';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { RedisSubscriber } from '../../services/queues/redis-subscriber.service';
+import { WorkflowRuntimeService } from '../../services/workflow/workflow-runtime.service';
+import workflowExecutionQueueOptions from './workflow-execution-queue-options-redis';
+
+@Injectable()
+export class WorkflowExecutionSubscriberRedis extends RedisSubscriber<WorkflowExecutionQueuePayload> {
+  private readonly workflowExecutionLogger = new Logger(WorkflowExecutionSubscriberRedis.name);
+
+  constructor(
+    readonly mqMessageService: MqMessageService,
+    readonly mqMessageQueueService: MqMessageQueueService,
+    private readonly workflowRuntimeService: WorkflowRuntimeService,
+  ) {
+    super(mqMessageService, mqMessageQueueService);
+  }
+
+  options(): QueuesModuleOptions {
+    return {
+      ...workflowExecutionQueueOptions,
+    };
+  }
+
+  async subscribe(message: QueueMessage<WorkflowExecutionQueuePayload>) {
+    const payload = message.payload;
+    this.workflowExecutionLogger.log(
+      `Processing queued workflow execution message ${message.messageId ?? '<unknown>'}.`,
+    );
+
+    if (payload.executionId !== undefined && payload.executionId !== null) {
+      return this.workflowRuntimeService.executeEnqueuedExecution(payload.executionId);
+    }
+
+    throw new Error('Workflow execution queue payload must include executionId.');
+  }
+}

package/src/repository/security-rule.repository.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { CreateSecurityRuleDto } from 'src/dtos/create-security-rule.dto';
 import { SecurityRuleConfig } from 'src/dtos/security-rule-config.dto';
 import { UpdateSecurityRuleDto } from 'src/dtos/update-security-rule.dto';
@@ -64,16 +64,37 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
         }
 
 
+        // A rule whose filters contribute no conditions is dangerous here: TypeORM renders an empty
+        // Brackets as "1=1" (always true), so such a rule would be OR'd in as "match everything" and
+        // silently void the entire security filter. Test emptiness explicitly -- {} and [] are both
+        // truthy, so the previous `if (evaluatedRule.filters)` check let them through.
+        const applicableRules = evaluatedRules.filter(rule => rule && this.hasFilterConditions(rule.filters));
+
+        if (!applicableRules.length) {
+            // We only reach here when security rules exist for this model/role (there is an early
+            // return above otherwise), so a restriction WAS intended. Fail closed and be loud:
+            // denying silently would surface as a mysteriously empty list, and allowing would be a
+            // full row-level-security bypass.
+            const message = `Security rules for model '${modelSingularName}' produced no filter conditions. `
+                + `Check the securityRuleConfig / securityRuleConfigProvider for rules with empty filters. `
+                + `Denying access rather than returning unrestricted results.`;
+            this.logger.error(message);
+            throw new InternalServerErrorException(message);
+        }
+
         // Apply each security rule to the query builder. The rules are combined with OR logic at the top level.
-        qb.andWhere(new Brackets(async (outerQb) => {
-            for (const evaluatedRule of evaluatedRules) {
-                if (evaluatedRule && evaluatedRule.filters) {
-                    outerQb.orWhere( // combine each rule-group with OR at the outer level
-                        new Brackets((innerQb) => {
-                            this.crudHelperService.applyFilters(innerQb, evaluatedRule.filters, securityRuleAlias, qb); // AND within a rule
-                        })
-                    );
-                }
+        qb.andWhere(new Brackets((outerQb) => {
+            for (const evaluatedRule of applicableRules) {
+                outerQb.orWhere( // combine each rule-group with OR at the outer level
+                    new Brackets((innerQb) => {
+                        // NOTE: do NOT wrap this in try/catch. Field validation inside applyFilters
+                        // throws on an invalid rule field, and letting it propagate aborts the
+                        // request with no rows -- i.e. it fails closed. Swallowing it would leave
+                        // this Brackets empty, which TypeORM renders as "1=1", turning the rule into
+                        // "match everything" and voiding row-level security entirely.
+                        this.crudHelperService.applyFilters(innerQb, evaluatedRule.filters, securityRuleAlias, qb); // AND within a rule
+                    })
+                );
             }
         }));
 
@@ -84,6 +105,27 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
         return configString.replace('$activeUserId', activeUser.sub.toString());
     }
 
+    /**
+     * Does this filter object actually produce at least one WHERE condition?
+     *
+     * Truthiness is not enough: `{}` and `[]` are truthy but contribute nothing, and an empty
+     * Brackets is rendered by TypeORM as "1=1" -- which inside the security rules' OR chain means
+     * "match every row". Recurses through $and/$or so `{ $and: [] }` is treated as empty too.
+     */
+    private hasFilterConditions(filters: any): boolean {
+        if (filters === null || filters === undefined) return false;
+        if (Array.isArray(filters)) return filters.some(filter => this.hasFilterConditions(filter));
+        if (typeof filters !== 'object') return false;
+
+        return Object.keys(filters).some(key => {
+            const normalizedKey = key.replace(/^\[(.*)\]$/, '$1');
+            if (normalizedKey === '$and' || normalizedKey === '$or') {
+                return this.hasFilterConditions(filters[key]);
+            }
+            return true; // any other key is a field condition
+        });
+    }
+
     async toDto(securityRule: SecurityRule): Promise<UpdateSecurityRuleDto> {
         // load the role and model relations for the security rule
         let populatedSecurityRule: SecurityRule = securityRule;

package/src/repository/workflow-definition.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 { WorkflowDefinition } from '../entities/workflow-definition.entity';
+
+@Injectable()
+export class WorkflowDefinitionRepository extends SolidBaseRepository<WorkflowDefinition> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowDefinition, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/workflow-execution-artifact.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 { WorkflowExecutionArtifact } from '../entities/workflow-execution-artifact.entity';
+
+@Injectable()
+export class WorkflowExecutionArtifactRepository extends SolidBaseRepository<WorkflowExecutionArtifact> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowExecutionArtifact, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/workflow-execution-log.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 { WorkflowExecutionLog } from '../entities/workflow-execution-log.entity';
+
+@Injectable()
+export class WorkflowExecutionLogRepository extends SolidBaseRepository<WorkflowExecutionLog> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowExecutionLog, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/workflow-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 { WorkflowExecution } from '../entities/workflow-execution.entity';
+
+@Injectable()
+export class WorkflowExecutionRepository extends SolidBaseRepository<WorkflowExecution> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowExecution, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/workflow-secret.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 { WorkflowSecret } from '../entities/workflow-secret.entity';
+
+@Injectable()
+export class WorkflowSecretRepository extends SolidBaseRepository<WorkflowSecret> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowSecret, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/workflow-step-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 { WorkflowStepExecution } from '../entities/workflow-step-execution.entity';
+
+@Injectable()
+export class WorkflowStepExecutionRepository extends SolidBaseRepository<WorkflowStepExecution> {
+    constructor(
+        @InjectDataSource("default")
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(WorkflowStepExecution, dataSource, requestContextService, securityRuleRepository);
+    }
+}