@aristid/leav-types 1.12.0-f8d42691 → 1.13.0-059eaf22

package/apps/core/config/default.d.ts

@@ -9,6 +9,9 @@ export declare namespace server {
     let allowIntrospection: boolean;
     let uploadLimit: string;
     let supportEmail: string;
+    namespace trpc {
+        let ssePingIntervalMs: string | number;
+    }
     namespace admin {
         let login: string;
         let password: string;
@@ -105,6 +108,10 @@ export declare namespace actions {
     namespace excel {
         let debug: boolean;
     }
+    namespace jexl {
+        let debug_1: boolean;
+        export { debug_1 as debug };
+    }
 }
 export declare namespace bugsnag {
     let enable_1: boolean;
@@ -230,7 +237,7 @@ export declare namespace indexationManager {
     }
     export { queues_3 as queues };
 }
-declare let debug_1: boolean;
+declare let debug_2: boolean;
 export declare let defaultUserId: string;
 export declare namespace _export {
     let directory_1: string;
@@ -291,4 +298,4 @@ export declare namespace automation {
     let enable_7: boolean;
     export { enable_7 as enable };
 }
-export { debug_1 as debug, _export as export, _import as import };
+export { debug_2 as debug, _export as export, _import as import };

package/apps/core/src/_types/automation.d.ts

@@ -1,4 +1,5 @@
 import { type EventAction, type IDbPayload } from '@leav/utils';
+import { type AutomationRulePipeline } from '../domain/automation/pipeline/_types';
 export type IAutomationRule = ICoreEntity & {
     createdAt: number;
     createdBy: string;
@@ -9,24 +10,34 @@ export type IAutomationRule = ICoreEntity & {
     description?: string;
     active: boolean;
     trigger: AutomationRuleTrigger;
+    pipeline: AutomationRulePipeline;
 };
 export type ICreateAutomationRule = {
     label: string;
     description?: string;
     trigger: AutomationRuleTrigger;
+    pipeline: AutomationRulePipeline;
+    active: boolean;
 };
 export type IUpdateAutomationRule = {
     id: string;
     label?: string;
     description?: string;
     active?: boolean;
-    trigger?: Partial<AutomationRuleTrigger>;
-};
-export type AutomationRuleTrigger = {
-    synchronous: boolean;
-    eventAction: EventAction | SyncAutomationRuleEventAction;
-    eventTopic?: IDbPayload['topic'];
+    trigger?: AutomationRuleTrigger;
+    pipeline?: AutomationRulePipeline;
 };
+export declare enum AutomationRuleJsonSchemaFormType {
+    CREATION = "creation",
+    EDITION = "edition"
+}
 export declare enum SyncAutomationRuleEventAction {
     RECORD_INIT = "RECORD_INIT"
 }
+export type AutomationRuleEventAction = EventAction | SyncAutomationRuleEventAction;
+export type AutomationRulesEventTopic = IDbPayload['topic'];
+export type AutomationRuleTrigger = {
+    synchronous: boolean;
+    eventAction: AutomationRuleEventAction;
+    eventTopic?: AutomationRulesEventTopic;
+};

package/apps/core/src/_types/config.d.ts

@@ -60,6 +60,9 @@ export interface IServer {
     allowIntrospection: boolean;
     uploadLimit: number | string;
     supportEmail: string;
+    trpc: {
+        ssePingIntervalMs: number;
+    };
     admin: {
         login: string;
         password: string;
@@ -77,6 +80,12 @@ export interface IActions {
          */
         debug: boolean;
     };
+    jexl: {
+        /**
+         * Add debug log for each calculation with formula and result or error
+         */
+        debug: boolean;
+    };
 }
 export interface IDb {
     url: string;

package/apps/core/src/_types/errors.d.ts

@@ -7,6 +7,11 @@ export declare enum ErrorTypes {
 export declare enum Errors {
     APP_STUDIO_WORKSPACE_LIBRARY_ID_REQUIRED = "APP_STUDIO_WORKSPACE_LIBRARY_ID_REQUIRED",
     APP_STUDIO_WORKSPACE_RECORD_ID_REQUIRED = "APP_STUDIO_WORKSPACE_RECORD_ID_REQUIRED",
+    AUTOMATION_UNKNOWN_TRIGGER_EVENT_ACTION = "AUTOMATION_UNKNOWN_TRIGGER_EVENT_ACTION",
+    AUTOMATION_INVALID_TRIGGER_EVENT_TOPIC = "AUTOMATION_INVALID_TRIGGER_EVENT_TOPIC",
+    AUTOMATION_INVALID_TRIGGER_ONLY_SYNC = "AUTOMATION_INVALID_TRIGGER_ONLY_SYNC",
+    AUTOMATION_INVALID_TRIGGER_ONLY_ASYNC = "AUTOMATION_INVALID_TRIGGER_ONLY_ASYNC",
+    AUTOMATION_RULE_PIPELINE_EMPTY = "AUTOMATION_RULE_PIPELINE_EMPTY",
     ATTRIBUTE_USED_BY_LIBRARY = "ATTRIBUTE_USED_BY_LIBRARY",
     ATTRIBUTE_USED_IN_METADATA = "ATTRIBUTE_USED_IN_METADATA",
     CANNOT_SAVE_METADATA = "CANNOT_SAVE_METADATA",
@@ -28,6 +33,8 @@ export declare enum Errors {
     FORMAT_ERROR = "FORMAT_ERROR",
     IMMUTABLE_CORE_SYSTEM_ATTRIBUTE = "IMMUTABLE_CORE_SYSTEM_ATTRIBUTE",
     INVALID_ACTION_TYPE = "INVALID_ACTION_TYPE",
+    INVALID_AUTOMATION_ACTION_PARAMS = "INVALID_AUTOMATION_ACTION_PARAMS",
+    INVALID_AUTOMATION_ACTION_TYPE = "INVALID_AUTOMATION_ACTION_TYPE",
     INVALID_ATTRIBUTE_TYPE = "INVALID_ATTRIBUTE_TYPE",
     INVALID_ATTRIBUTE_FILTER_FORMAT = "INVALID_ATTRIBUTE_FILTER_FORMAT",
     INVALID_ATTRIBUTE_FOR_LIBRARY = "INVALID_ATTRIBUTE_FOR_LIBRARY",
@@ -45,6 +52,7 @@ export declare enum Errors {
     INVALID_MAPPING = "INVALID_MAPPING",
     INVALID_PERMISSIONS_CONF_LIBRARIES = "INVALID_PERMISSIONS_CONF_LIBRARIES",
     INVALID_REGEXP = "INVALID_REGEXP",
+    INVALID_JEXL_EXPRESSION = "INVALID_JEXL_EXPRESSION",
     INVALID_SORT_FIELDS = "INVALID_SORT_FIELDS",
     INVALID_TREE_FILTER_FORMAT = "INVALID_TREE_FILTER_FORMAT",
     INVALID_URL = "INVALID_URL",

package/apps/core/src/_types/events.d.ts

@@ -10,6 +10,7 @@ import { type IVersionProfile } from './versionProfile';
 import { type IPermission } from './permissions';
 import { type ITreeDbEvent, type ITree } from './tree';
 import { type IAutomationRule } from './automation';
+import { type IAutomationPipelineFailure, type IAutomationPipelineSuccess } from '../domain/automation/pipeline/_types';
 type OnlyObject<T> = T extends object ? T : never;
 /**
  * Maybe move all DBPayloadData types in @leav/utils type to allow event consumers outside core to use them
@@ -33,6 +34,8 @@ interface IDBPayloadDataMap {
     [EventAction.APP_DELETE]: IApplication;
     [EventAction.AUTOMATION_RULE_CREATE]: IAutomationRule;
     [EventAction.AUTOMATION_RULE_UPDATE]: IAutomationRule;
+    [EventAction.AUTOMATION_PIPELINE_SUCCESS]: IAutomationPipelineSuccess;
+    [EventAction.AUTOMATION_PIPELINE_FAILURE]: IAutomationPipelineFailure;
     [EventAction.GLOBAL_SETTINGS_SAVE]: IGlobalSettings;
     [EventAction.LIBRARY_SAVE]: ILibraryDbEvent;
     [EventAction.LIBRARY_DELETE]: ILibraryDbEvent;

package/apps/core/src/_types/eventsManager.d.ts

@@ -1,4 +1,5 @@
 import { type INotification } from './notification';
+import { type IRecord } from './record';
 import { type ITask } from './tasksManager';
 export declare enum TriggerNames {
     APPLICATION_EVENT = "APPLICATION_EVENT",
@@ -7,6 +8,7 @@ export declare enum TriggerNames {
     TASK = "TASK",
     TREE_EVENT = "TREE_EVENT",
     RECORD_UPDATE = "RECORD_UPDATE",
+    RECORD_NEW_COMMENT = "RECORD_NEW_COMMENT",
     NOTIFICATION = "NOTIFICATION"
 }
 export interface IPubSubNotificationData {
@@ -16,3 +18,9 @@ export interface IPubSubNotificationData {
 export interface IPubSubTaskData {
     task: ITask;
 }
+export interface IPubSubRecordNewCommentData {
+    recordNewComment: {
+        record: IRecord;
+        comment: IRecord;
+    };
+}

package/apps/core/src/_types/extensionPoints.d.ts

@@ -4,6 +4,7 @@ import { type PermissionTypes } from './permissions';
 import { type PluginRegisterRoute } from './endpoint';
 import { type AuthPostOidcLoginCallback } from './auth';
 import { type RegisterCronTask } from './cronTask';
+import { type ITRPCRouterFactory } from '../app/trpc/trpcApp';
 export interface IExtensionPoints {
     [name: string]: (...args: any[]) => void;
 }
@@ -16,6 +17,7 @@ export interface IExtensionPointsFunctions extends IExtensionPoints {
      * @param {IAppGraphQLSchema} schemaPart
      */
     registerGraphQLSchema: (schemaPart: IAppGraphQLSchema) => void;
+    registerTRPCRouter: (initRouter: ITRPCRouterFactory) => void;
     registerTranslations: (path: string) => Promise<void>;
     registerPermissionActions: (type: PermissionTypes, actions: string[], applyOn?: string[]) => void;
     registerEventActions: (actions: string[], prefix: string) => void;

package/apps/core/src/_types/record.d.ts

@@ -102,6 +102,7 @@ export interface IRecordUpdateEventFilters {
     libraries?: string[];
     records?: string[];
 }
+export type IRecordCommentEventFilters = IRecordUpdateEventFilters;
 export interface IRecordFilterLight {
     field?: string;
     value?: string;

package/apps/core/src/app/core/automationApp.d.ts

@@ -2,11 +2,13 @@ import { type IGraphqlAppModule } from '../graphql/graphqlApp';
 import { type IAutomationDomain } from '../../domain/automation/automationDomain';
 import { type IAutomationRule } from '../../_types/automation';
 import { type IPaginationParams, type ISortParams } from '../../_types/list';
-import { type IEventsManagerDomain } from '../../domain/eventsManager/eventsManagerDomain';
+import { type IAutomationTriggers } from '../../domain/automation/triggers/automationTriggers';
+import { type IAutomationTriggersRegistry } from '../..//domain/automation/triggers/automationTriggersRegistry';
 export type ICoreImportApp = IGraphqlAppModule;
 interface IAutomationAppDeps {
     'core.domain.automation': IAutomationDomain;
-    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.automation.triggers': IAutomationTriggers;
+    'core.domain.automation.triggers.registry': IAutomationTriggersRegistry;
 }
 export interface IGetAutomationRulesArgs {
     filters?: ICoreEntityFilterOptions & {
@@ -18,5 +20,5 @@ export interface IGetAutomationRulesArgs {
     pagination?: IPaginationParams;
     sort?: ISortParams;
 }
-export default function ({ 'core.domain.automation': automationDomain, 'core.domain.eventsManager': eventsManagerDomain, }: IAutomationAppDeps): ICoreImportApp;
+export default function ({ 'core.domain.automation': automationDomain, 'core.domain.automation.triggers': automationTriggers, 'core.domain.automation.triggers.registry': automationTriggersRegistry, }: IAutomationAppDeps): ICoreImportApp;
 export {};

package/apps/core/src/app/trpc/index.d.ts

@@ -0,0 +1 @@
+export { default } from './trpcApp';

package/apps/core/src/app/trpc/trpcApp.d.ts

@@ -0,0 +1,30 @@
+import { type IAppModule } from '../../_types/shared';
+import { type IQueryInfos } from '../../_types/queryInfos';
+import { type CreateExpressContextOptions } from '@trpc/server/adapters/express';
+import { type Handler } from 'express';
+import { type IConfig } from '../../_types/config';
+import { type ILogger } from '@leav/logger';
+export interface ITRPCApp extends IAppModule {
+    createExpressHandler: (initContext: (opts: CreateExpressContextOptions) => Promise<IQueryInfos>) => Handler;
+}
+declare const createTrpc: (config: IConfig) => import("@trpc/server").TRPCRootObject<IQueryInfos, object, {
+    sse: {
+        ping: {
+            enabled: true;
+            intervalMs: number;
+        };
+    };
+}, {
+    ctx: IQueryInfos;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}>;
+export type TTrpc = ReturnType<typeof createTrpc>;
+export type ITRPCRouterFactory = (trpc: TTrpc) => ReturnType<TTrpc['router']>;
+interface IDeps {
+    config: IConfig;
+    'core.utils.logger'?: ILogger;
+}
+export default function ({ config, 'core.utils.logger': logger }: IDeps): ITRPCApp;
+export {};

package/apps/core/src/domain/actions/index.d.ts

@@ -1,6 +1,7 @@
 export { default as dateRangeToNumberAction } from './dateRangeToNumberAction';
 export { default as encryptAction } from './encryptAction';
 export { default as excelAction } from './excelCalculationAction';
+export { default as jexlCalculationAction } from './jexlCalculationAction';
 export { default as formatDateAction } from './formatDateAction';
 export { default as formatDateRangeAction } from './formatDateRangeAction';
 export { default as formatNumberAction } from './formatNumberAction';

package/apps/core/src/domain/actions/jexlCalculationAction.d.ts

@@ -0,0 +1,14 @@
+import { type IJexlDomain } from '../jexl/jexlDomain';
+import { type IActionsListFunction } from '../../_types/actionsList';
+import { type IConfig } from '../../_types/config';
+interface IDeps {
+    'core.domain.jexl': IJexlDomain;
+    config: IConfig;
+}
+type ActionParams = {
+    Formula: true;
+    Description: true;
+    ['Return only calculated value']: false;
+};
+export default function ({ 'core.domain.jexl': jexlDomain, config }: IDeps): IActionsListFunction<ActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/_types.d.ts

@@ -0,0 +1,35 @@
+import { type ZodObject } from 'zod';
+import { type AutomationRulePipelineStep, type IAutomationPipelineExecutionState } from '../pipeline/_types';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type AutomationRuleTrigger } from '../../../_types/automation';
+export declare enum AutomationRuleActions {
+    LOG = "log",
+    CONDITION = "condition",
+    ERROR = "error",
+    JEXL_CALCULATION = "jexlCalculation",
+    MODIFY_ATTRIBUTE = "modifyAttribute",
+    NOTIFICATION = "notification"
+}
+export type AutomationPipelineStepValidation<Params = unknown> = {
+    readonly step: AutomationRulePipelineStep<Params>;
+    readonly stepIndex: number;
+    readonly trigger: AutomationRuleTrigger;
+    readonly precedingStepsByExecOrder: AutomationRulePipelineStep[];
+};
+export interface IAutomationAction<Params = unknown> {
+    readonly type: AutomationRuleActions | string;
+    readonly paramsSchema: ZodObject<any>;
+    validateStep?: (params: AutomationPipelineStepValidation<Params>, ctx: IQueryInfos) => Promise<void>;
+    execute(params: Params, state: IAutomationPipelineExecutionState, ctx: IQueryInfos): Promise<IActionExecutionResult | void>;
+}
+export declare enum ActionExecutionResultStatus {
+    CONTINUE = "continue",
+    STOP = "stop"
+}
+export type IActionExecutionResult = {
+    status: ActionExecutionResultStatus.CONTINUE;
+    result?: unknown;
+} | {
+    status: ActionExecutionResultStatus.STOP;
+    reason?: string;
+};

package/apps/core/src/domain/automation/actions/conditionAction.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+import { type BuildAutomationJexlContext } from '../pipeline/buildAutomationJexlContext';
+import { type IJexlDomain } from '../../jexl/jexlDomain';
+declare const conditionActionParamsSchema: z.ZodObject<{
+    expression: z.ZodString;
+}, z.core.$strip>;
+export type ConditionActionParams = z.infer<typeof conditionActionParamsSchema>;
+interface IConditionActionDeps {
+    'core.domain.jexl': IJexlDomain;
+    'core.domain.automation.pipeline.buildAutomationJexlContext': BuildAutomationJexlContext;
+}
+export default function ({ 'core.domain.jexl': jexl, 'core.domain.automation.pipeline.buildAutomationJexlContext': buildAutomationJexlContext, }: IConditionActionDeps): IAutomationAction<ConditionActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/errorAction.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+declare const errorActionParamsSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ErrorActionParams = z.infer<typeof errorActionParamsSchema>;
+export default function (): IAutomationAction<ErrorActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/index.d.ts

@@ -0,0 +1,6 @@
+export { default as condition } from './conditionAction';
+export { default as error } from './errorAction';
+export { default as log } from './logAction';
+export { default as jexlCalculation } from './jexlCalculationAutomationAction';
+export { default as modifyAttribute } from './modifyAttributeAction';
+export { default as notification } from './notificationAction';

package/apps/core/src/domain/automation/actions/jexlCalculationAutomationAction.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { type IJexlDomain } from '../../jexl/jexlDomain';
+import { type IConfig } from '../../../_types/config';
+import { type IAutomationAction } from './_types';
+import { type BuildAutomationJexlContext } from '../pipeline/buildAutomationJexlContext';
+declare const jexlCalculationActionParamsSchema: z.ZodObject<{
+    formula: z.ZodString;
+}, z.core.$strip>;
+export type JexlCalculationActionParams = z.infer<typeof jexlCalculationActionParamsSchema>;
+interface IDeps {
+    'core.domain.jexl': IJexlDomain;
+    config: IConfig;
+    'core.domain.automation.pipeline.buildAutomationJexlContext': BuildAutomationJexlContext;
+}
+export default function ({ 'core.domain.jexl': jexlDomain, config, 'core.domain.automation.pipeline.buildAutomationJexlContext': buildAutomationJexlContext, }: IDeps): IAutomationAction<JexlCalculationActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/logAction.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+declare const logActionParamsSchema: z.ZodObject<{
+    message: z.ZodString;
+    level: z.ZodOptional<z.ZodEnum<{
+        info: "info";
+        error: "error";
+        debug: "debug";
+        silly: "silly";
+        verbose: "verbose";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+export type LogActionParams = z.infer<typeof logActionParamsSchema>;
+export default function (): IAutomationAction<LogActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/modifyAttributeAction.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+import { type IValueDomain } from '../../value/valueDomain';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type IValidateHelper } from '../../helpers/validate';
+declare const modifyAttributeActionParamsSchema: z.ZodObject<{
+    attributePath: z.ZodString;
+    mode: z.ZodEnum<{
+        replace: "replace";
+        add: "add";
+    }>;
+}, z.core.$strip>;
+export type ModifyAttributeActionParams = z.infer<typeof modifyAttributeActionParamsSchema>;
+interface IDeps {
+    'core.domain.value': IValueDomain;
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.helpers.validate': IValidateHelper;
+}
+export default function ({ 'core.domain.value': valueDomain, 'core.domain.attribute': attributeDomain, 'core.domain.helpers.validate': validateHelper, }: IDeps): IAutomationAction<ModifyAttributeActionParams>;
+export {};

package/apps/core/src/domain/automation/actions/notificationAction.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+import { type IJexlDomain } from '../../jexl/jexlDomain';
+import { type INotificationDomain } from '../../notification/notificationDomain';
+import { type BuildAutomationJexlContext } from '../pipeline/buildAutomationJexlContext';
+declare const notificationActionParamsSchema: z.ZodObject<{
+    title: z.ZodString;
+    recipients: z.ZodString;
+    message: z.ZodString;
+    mail: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NotificationActionParams = z.infer<typeof notificationActionParamsSchema>;
+interface INotificationActionDeps {
+    'core.domain.jexl': IJexlDomain;
+    'core.domain.notification': INotificationDomain;
+    'core.domain.automation.pipeline.buildAutomationJexlContext': BuildAutomationJexlContext;
+}
+export default function ({ 'core.domain.jexl': jexl, 'core.domain.notification': notification, 'core.domain.automation.pipeline.buildAutomationJexlContext': buildAutomationJexlContext, }: INotificationActionDeps): IAutomationAction<NotificationActionParams>;
+export {};

package/apps/core/src/domain/automation/automationActionsRegistry.d.ts

@@ -0,0 +1,10 @@
+import { type AwilixContainer } from 'awilix';
+import { type IAutomationAction, type AutomationRuleActions } from './actions/_types';
+export interface IAutomationActionsRegistry {
+    getAction(type: AutomationRuleActions | string): IAutomationAction | undefined;
+    listAvailableActions(): IAutomationAction[];
+}
+export interface IAutomationActionsRegistryDeps {
+    'core.depsManager': AwilixContainer;
+}
+export default function ({ 'core.depsManager': depsManager, }: IAutomationActionsRegistryDeps): IAutomationActionsRegistry;

package/apps/core/src/domain/automation/automationDomain.d.ts

@@ -1,4 +1,4 @@
-import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule } from '../../_types/automation';
+import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule, type AutomationRulesEventTopic, type AutomationRuleEventAction, type AutomationRuleJsonSchemaFormType } from '../../_types/automation';
 import { type IList } from '../../_types/list';
 import { type IQueryInfos } from '../../_types/queryInfos';
 import { type IGetCoreEntitiesParams } from '../../_types/shared';
@@ -6,19 +6,41 @@ import { type IAutomationRuleRepo } from '../../infra/automation/automationRuleR
 import { type IAdminPermissionDomain } from '../permission/adminPermissionDomain';
 import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
 import { type IConfig } from '../../_types/config';
+import { type IAutomationPipelineDomain } from './pipeline/pipeline';
+import { type IAutomationTriggers } from './triggers/automationTriggers';
+import { type AutomationTriggerDef } from './triggers/_types';
+import { type IAutomationJsonSchemaFormDomain } from './form/automationJsonSchemaForm';
+import { type IAutomationUiJsonSchemaFormDomain } from './form/automationUiJsonSchemaForm';
+import { type UiSchema, type RJSFSchema } from '@rjsf/utils';
 export interface IGetAutomationRulesParams extends IGetCoreEntitiesParams {
     filters?: ICoreEntityFilterOptions & {
         active?: boolean;
         synchronous?: boolean;
-        eventAction?: IAutomationRule['trigger']['eventAction'];
-        eventTopic?: IAutomationRule['trigger']['eventTopic'];
+        eventAction?: AutomationRuleEventAction;
+        eventTopic?: AutomationRulesEventTopic;
     };
 }
+interface ITriggerRulesParams {
+    event: {
+        action: IAutomationRule['trigger']['eventAction'];
+        topic?: IAutomationRule['trigger']['eventTopic'];
+    };
+    synchronous: boolean;
+    ctx: IQueryInfos;
+}
 export interface IAutomationDomain {
     getAutomationRules({ params, ctx, }: {
         params: IGetAutomationRulesParams;
         ctx: IQueryInfos;
     }): Promise<IList<IAutomationRule>>;
+    getAutomationRuleJsonSchemaForm({ formType, ctx, }: {
+        formType: AutomationRuleJsonSchemaFormType;
+        ctx: IQueryInfos;
+    }): Promise<RJSFSchema>;
+    getAutomationRuleUiJsonSchemaForm({ formType, ctx, }: {
+        formType: AutomationRuleJsonSchemaFormType;
+        ctx: IQueryInfos;
+    }): Promise<UiSchema>;
     createAutomationRule({ rule, ctx }: {
         rule: ICreateAutomationRule;
         ctx: IQueryInfos;
@@ -27,15 +49,24 @@ export interface IAutomationDomain {
         rule: IUpdateAutomationRule;
         ctx: IQueryInfos;
     }): Promise<IAutomationRule>;
-    triggerRules(event: {
-        action: IAutomationRule['trigger']['eventAction'];
-        topic?: IAutomationRule['trigger']['eventTopic'];
-    }, synchronous: boolean, ctx: IQueryInfos): Promise<void>;
+    deleteAutomationRule({ ruleId, ctx }: {
+        ruleId: string;
+        ctx: IQueryInfos;
+    }): Promise<IAutomationRule>;
+    triggerRules(params: ITriggerRulesParams): Promise<void>;
+    listAutomationTriggersDef({ ctx }: {
+        ctx: IQueryInfos;
+    }): Promise<AutomationTriggerDef[]>;
 }
 export interface IAutomationDomainDeps {
+    'core.domain.automation.triggers': IAutomationTriggers;
+    'core.domain.automation.form': IAutomationJsonSchemaFormDomain;
+    'core.domain.automation.form.uiJsonSchemaForm': IAutomationUiJsonSchemaFormDomain;
     'core.domain.permission.admin': IAdminPermissionDomain;
     'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.automation.pipeline': IAutomationPipelineDomain;
     'core.infra.automation.rule': IAutomationRuleRepo;
     config: IConfig;
 }
-export default function ({ 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.infra.automation.rule': automationRuleRepo, config, }: IAutomationDomainDeps): IAutomationDomain;
+export default function ({ 'core.domain.automation.triggers': automationTriggers, 'core.domain.automation.form': automationJsonSchemaFormDomain, 'core.domain.automation.form.uiJsonSchemaForm': automationUiJsonSchemaFormDomain, 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.automation.pipeline': pipelineDomain, 'core.infra.automation.rule': automationRuleRepo, config, }: IAutomationDomainDeps): IAutomationDomain;
+export {};

package/apps/core/src/domain/automation/fakeRulesToTrigger.d.ts

@@ -0,0 +1,7 @@
+import { type AutomationRuleEventAction, type AutomationRulesEventTopic, type IAutomationRule } from '../../_types/automation';
+import { type IQueryInfos } from '../../_types/queryInfos';
+export declare const TRIGGER_FAKER_RULES_FOR_DEV = false;
+export declare const buildFakeRulesToTrigger: (event: {
+    action: AutomationRuleEventAction;
+    topic?: AutomationRulesEventTopic;
+}, synchronous: boolean, ctx: IQueryInfos) => Promise<IAutomationRule[]>;

package/apps/core/src/domain/automation/form/automationJsonSchemaForm.d.ts

@@ -0,0 +1,19 @@
+import { AutomationRuleJsonSchemaFormType } from '../../../_types/automation';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IAutomationTriggersRegistry } from '../triggers/automationTriggersRegistry';
+import { type RJSFSchema } from '@rjsf/utils';
+export interface IAutomationJsonSchemaFormDomain {
+    getAutomationRuleJsonSchemaForm({ formType, ctx, }: {
+        formType: AutomationRuleJsonSchemaFormType;
+        ctx: IQueryInfos;
+    }): Promise<RJSFSchema>;
+}
+interface IAutomationJsonSchemaFormDomainDeps {
+    'core.domain.automation.triggers.registry': IAutomationTriggersRegistry;
+}
+export declare const extractAndLiftDefs: (jsonSchema: RJSFSchema) => {
+    schema: RJSFSchema;
+    defs: Record<string, RJSFSchema>;
+};
+export default function ({ 'core.domain.automation.triggers.registry': automationTriggersRegistry, }: IAutomationJsonSchemaFormDomainDeps): IAutomationJsonSchemaFormDomain;
+export {};

package/apps/core/src/domain/automation/form/automationUiJsonSchemaForm.d.ts

@@ -0,0 +1,15 @@
+import { type i18n } from 'i18next';
+import { type UiSchema } from '@rjsf/utils';
+import { AutomationRuleJsonSchemaFormType } from '../../../_types/automation';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+export interface IAutomationUiJsonSchemaFormDomain {
+    getAutomationRuleUiJsonSchemaForm({ formType, ctx, }: {
+        formType: AutomationRuleJsonSchemaFormType;
+        ctx: IQueryInfos;
+    }): Promise<UiSchema>;
+}
+interface IAutomationUiJsonSchemaFormDomainDeps {
+    translator: i18n;
+}
+export default function ({ translator }: IAutomationUiJsonSchemaFormDomainDeps): IAutomationUiJsonSchemaFormDomain;
+export {};

package/apps/core/src/domain/automation/form/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './automationJsonSchemaForm';
+export { default as uiJsonSchemaForm } from './automationUiJsonSchemaForm';

package/apps/core/src/domain/automation/index.d.ts

@@ -1 +1,5 @@
 export { default } from './automationDomain';
+export { default as actionsRegistry } from './automationActionsRegistry';
+export { default as form } from './form';
+export { default as pipeline } from './pipeline';
+export { default as triggers } from './triggers';

package/apps/core/src/domain/automation/pipeline/_types.d.ts

@@ -0,0 +1,37 @@
+import { type AutomationRuleTrigger } from '../../../_types/automation';
+import { type AutomationRuleActions } from '../actions/_types';
+export type AutomationRulePipeline = {
+    steps: AutomationRulePipelineStep[];
+};
+export type AutomationRulePipelineStep<Params = unknown> = {
+    type: AutomationRuleActions | string;
+    name?: string;
+    params: Params;
+};
+export type IAutomationPipelineFailure = {
+    readonly results: Record<string, unknown | {
+        stack?: string;
+        message: string;
+        name: string;
+        [k: string]: unknown;
+    }>;
+};
+export type IAutomationPipelineSuccess = {
+    readonly results: Record<string, unknown>;
+};
+export type IAutomationPipelineExecutionState = {
+    readonly trigger: AutomationRuleTrigger;
+    readonly results: IAutomationPipelineExecutionResults;
+    readonly lastResult?: unknown;
+    readonly startDateMs: number;
+    stepIndex: number;
+};
+export type IAutomationPipelineExecutionResults = Record<string, unknown>;
+export type AutomationPipeline = AutomationRulePipeline;
+export type AutomationPipelineExecution = AutomationPipeline & {
+    trigger: AutomationRuleTrigger;
+    ruleId: string;
+};
+export type AutomationPipelineValidation = AutomationPipeline & {
+    trigger: AutomationRuleTrigger;
+};

package/apps/core/src/domain/automation/pipeline/buildAutomationJexlContext.d.ts

@@ -0,0 +1,9 @@
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IJexlDomain } from '../../jexl/jexlDomain';
+import { type JexlRootContext } from '../../jexl/types';
+import { type IAutomationPipelineExecutionState } from './_types';
+export type BuildAutomationJexlContext = (executionState: IAutomationPipelineExecutionState, ctx: IQueryInfos) => JexlRootContext;
+export interface IBuildAutomationJexlContextDeps {
+    'core.domain.jexl': IJexlDomain;
+}
+export default function ({ 'core.domain.jexl': jexlDomain, }: IBuildAutomationJexlContextDeps): BuildAutomationJexlContext;

package/apps/core/src/domain/automation/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './pipeline';
+export { default as buildAutomationJexlContext } from './buildAutomationJexlContext';