@aristid/leav-types 1.12.0-a0a98764 → 1.12.0-b0c6d69c

package/CLAUDE.md

@@ -0,0 +1,42 @@
+# libs/types — CLAUDE.md
+
+`@aristid/leav-types` — Types TypeScript de `apps/core` publiés sur npm pour les plugins externes.
+
+## Ce que c'est
+
+Ce package ne contient **pas de code source** — c'est une projection des types générés
+depuis `apps/core`, destinée aux **développeurs de plugins** qui étendent le core.
+
+> ⚠️ Ce package **n'est pas utilisé dans le monorepo lui-même**. Il est uniquement
+> consommé par des repos externes (plugins tiers du core).
+
+## Publication CI (GitLab)
+
+Publié automatiquement sur **npm public** (`@aristid/leav-types`) via GitLab CI,
+déclenché par tout changement dans `apps/core/**/*` :
+
+-   **`next`** — à chaque push sur `develop`
+-   **`latest`** — sur les releases taguées
+
+```bash
+# Commande de génération (lancée par le CI)
+yarn workspace @aristid/leav-types generate
+```
+
+## Problème connu : les enums ne sont pas exportés ⚠️
+
+La commande `generate` (basée sur `build-types` du core) n'exporte pas les enums TypeScript.
+Les consommateurs du package doivent **réécrire les enums manuellement** de leur côté —
+ce qui est une source de désynchronisation et de maintenance coûteuse.
+
+**Piste de résolution envisagée :** publier davantage de code du core directement
+(pas uniquement les types), de façon à exposer les enums comme du code exécutable.
+C'est un chantier à prioriser.
+
+## Ne jamais modifier manuellement
+
+Toujours régénérer via le CI ou :
+
+```bash
+yarn workspace @aristid/leav-types generate
+```

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

@@ -287,4 +287,8 @@ export declare namespace logsCollector {
     let queue: string;
 }
 export declare let pluginsPath: string[];
+export declare namespace automation {
+    let enable_7: boolean;
+    export { enable_7 as enable };
+}
 export { debug_1 as debug, _export as export, _import as import };

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

@@ -14,3 +14,7 @@ export namespace dbProfiler {
 export namespace bugsnag {
     let releaseStage: string;
 }
+export namespace automation {
+    let enable_1: boolean;
+    export { enable_1 as enable };
+}

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

@@ -90,3 +90,7 @@ export namespace applications {
     let rootFolder: string;
     let assetsMaxAge: string;
 }
+export namespace automation {
+    let enable_3: boolean;
+    export { enable_3 as enable };
+}

package/apps/core/src/__tests__/e2e/_gqlTypes/index.d.ts

@@ -244,12 +244,53 @@ export declare enum AttributesSortableFields {
     multiple_values = "multiple_values",
     type = "type"
 }
+export declare enum AutomationRuleEventAction {
+    API_KEY_DELETE = "API_KEY_DELETE",
+    API_KEY_SAVE = "API_KEY_SAVE",
+    APP_DELETE = "APP_DELETE",
+    APP_SAVE = "APP_SAVE",
+    ATTRIBUTE_DELETE = "ATTRIBUTE_DELETE",
+    ATTRIBUTE_SAVE = "ATTRIBUTE_SAVE",
+    AUTOMATION_RULE_CREATE = "AUTOMATION_RULE_CREATE",
+    AUTOMATION_RULE_UPDATE = "AUTOMATION_RULE_UPDATE",
+    CONFIG_IMPORT_END = "CONFIG_IMPORT_END",
+    CONFIG_IMPORT_START = "CONFIG_IMPORT_START",
+    DATA_IMPORT_END = "DATA_IMPORT_END",
+    DATA_IMPORT_START = "DATA_IMPORT_START",
+    EXPORT_END = "EXPORT_END",
+    EXPORT_START = "EXPORT_START",
+    GLOBAL_SETTINGS_SAVE = "GLOBAL_SETTINGS_SAVE",
+    LIBRARY_DELETE = "LIBRARY_DELETE",
+    LIBRARY_PURGE = "LIBRARY_PURGE",
+    LIBRARY_SAVE = "LIBRARY_SAVE",
+    PERMISSION_SAVE = "PERMISSION_SAVE",
+    RECORD_DELETE = "RECORD_DELETE",
+    RECORD_INIT = "RECORD_INIT",
+    RECORD_SAVE = "RECORD_SAVE",
+    TASKS_DELETE = "TASKS_DELETE",
+    TREE_ADD_ELEMENT = "TREE_ADD_ELEMENT",
+    TREE_DELETE = "TREE_DELETE",
+    TREE_DELETE_ELEMENT = "TREE_DELETE_ELEMENT",
+    TREE_MOVE_ELEMENT = "TREE_MOVE_ELEMENT",
+    TREE_SAVE = "TREE_SAVE",
+    VALUE_DELETE = "VALUE_DELETE",
+    VALUE_SAVE = "VALUE_SAVE",
+    VERSION_PROFILE_DELETE = "VERSION_PROFILE_DELETE",
+    VERSION_PROFILE_SAVE = "VERSION_PROFILE_SAVE"
+}
 export declare enum AutomationRuleSortableFields {
     id = "id"
 }
+export type AutomationRuleTriggerInput = {
+    eventAction: AutomationRuleEventAction;
+    eventTopic?: InputMaybe<EventTopicInput>;
+    synchronous: Scalars['Boolean']['input'];
+};
 export type AutomationRulesFiltersInput = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
     id?: InputMaybe<Scalars['ID']['input']>;
     label?: InputMaybe<Scalars['String']['input']>;
+    trigger?: InputMaybe<PartialAutomationRuleTriggerInput>;
 };
 export type AutomationRulesSortInput = {
     field: AutomationRuleSortableFields;
@@ -259,16 +300,6 @@ export declare enum AvailableLanguage {
     en = "en",
     fr = "fr"
 }
-export type CampaignToRenew = {
-    endDate: Scalars['String']['input'];
-    id: Scalars['String']['input'];
-    startDate: Scalars['String']['input'];
-};
-export type CampaignToUpdateDates = {
-    endDate: Scalars['String']['input'];
-    id: Scalars['String']['input'];
-    startDate: Scalars['String']['input'];
-};
 export type ChildrenAsRecordValuePermissionFilterInput = {
     action: RecordPermissionsActions;
     attributeId: Scalars['ID']['input'];
@@ -277,6 +308,7 @@ export type ChildrenAsRecordValuePermissionFilterInput = {
 export type CreateAutomationRuleInput = {
     description?: InputMaybe<Scalars['SystemTranslationOptional']['input']>;
     label: Scalars['SystemTranslation']['input'];
+    trigger: AutomationRuleTriggerInput;
 };
 export type CreateRecordDataInput = {
     values?: InputMaybe<Array<ValueBatchInput>>;
@@ -313,6 +345,59 @@ export type EmbeddedAttributeInput = {
     label?: InputMaybe<Scalars['SystemTranslation']['input']>;
     validation_regex?: InputMaybe<Scalars['String']['input']>;
 };
+export declare enum EventAction {
+    API_KEY_DELETE = "API_KEY_DELETE",
+    API_KEY_SAVE = "API_KEY_SAVE",
+    APP_DELETE = "APP_DELETE",
+    APP_SAVE = "APP_SAVE",
+    ATTRIBUTE_DELETE = "ATTRIBUTE_DELETE",
+    ATTRIBUTE_SAVE = "ATTRIBUTE_SAVE",
+    AUTOMATION_RULE_CREATE = "AUTOMATION_RULE_CREATE",
+    AUTOMATION_RULE_UPDATE = "AUTOMATION_RULE_UPDATE",
+    CONFIG_IMPORT_END = "CONFIG_IMPORT_END",
+    CONFIG_IMPORT_START = "CONFIG_IMPORT_START",
+    DATA_IMPORT_END = "DATA_IMPORT_END",
+    DATA_IMPORT_START = "DATA_IMPORT_START",
+    EXPORT_END = "EXPORT_END",
+    EXPORT_START = "EXPORT_START",
+    GLOBAL_SETTINGS_SAVE = "GLOBAL_SETTINGS_SAVE",
+    LIBRARY_DELETE = "LIBRARY_DELETE",
+    LIBRARY_PURGE = "LIBRARY_PURGE",
+    LIBRARY_SAVE = "LIBRARY_SAVE",
+    PERMISSION_SAVE = "PERMISSION_SAVE",
+    RECORD_DELETE = "RECORD_DELETE",
+    RECORD_SAVE = "RECORD_SAVE",
+    TASKS_DELETE = "TASKS_DELETE",
+    TREE_ADD_ELEMENT = "TREE_ADD_ELEMENT",
+    TREE_DELETE = "TREE_DELETE",
+    TREE_DELETE_ELEMENT = "TREE_DELETE_ELEMENT",
+    TREE_MOVE_ELEMENT = "TREE_MOVE_ELEMENT",
+    TREE_SAVE = "TREE_SAVE",
+    VALUE_DELETE = "VALUE_DELETE",
+    VALUE_SAVE = "VALUE_SAVE",
+    VERSION_PROFILE_DELETE = "VERSION_PROFILE_DELETE",
+    VERSION_PROFILE_SAVE = "VERSION_PROFILE_SAVE"
+}
+export type EventTopicInput = {
+    apiKey?: InputMaybe<Scalars['String']['input']>;
+    application?: InputMaybe<Scalars['String']['input']>;
+    attribute?: InputMaybe<Scalars['String']['input']>;
+    automationRule?: InputMaybe<Scalars['String']['input']>;
+    filename?: InputMaybe<Scalars['String']['input']>;
+    library?: InputMaybe<Scalars['String']['input']>;
+    permission?: InputMaybe<EventTopicPermissionInput>;
+    profile?: InputMaybe<Scalars['String']['input']>;
+    record?: InputMaybe<EventTopicRecordInput>;
+    tree?: InputMaybe<Scalars['String']['input']>;
+};
+export type EventTopicPermissionInput = {
+    applyTo?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['String']['input'];
+};
+export type EventTopicRecordInput = {
+    id: Scalars['String']['input'];
+    libraryId: Scalars['String']['input'];
+};
 export type FileInput = {
     data: Scalars['Upload']['input'];
     replace?: InputMaybe<Scalars['Boolean']['input']>;
@@ -373,16 +458,6 @@ export declare enum FormsSortableFields {
     library = "library",
     system = "system"
 }
-export declare enum GenerationStatus {
-    DONE = "DONE",
-    GENERATION_FAILED = "GENERATION_FAILED",
-    GENERATION_IN_PROGRESS = "GENERATION_IN_PROGRESS",
-    GENERATION_IN_PROGRESS_WITH_FAILURE = "GENERATION_IN_PROGRESS_WITH_FAILURE",
-    PREPARATION_FAILED = "PREPARATION_FAILED",
-    PREPARATION_IN_PROGRESS = "PREPARATION_IN_PROGRESS",
-    TRANSMISSION_FAILED = "TRANSMISSION_FAILED",
-    TRANSMISSION_IN_PROGRESS = "TRANSMISSION_IN_PROGRESS"
-}
 export type GlobalSettingsFileInput = {
     library: Scalars['String']['input'];
     recordId: Scalars['String']['input'];
@@ -470,8 +545,6 @@ export declare enum LogAction {
     LIBRARY_PURGE = "LIBRARY_PURGE",
     LIBRARY_SAVE = "LIBRARY_SAVE",
     PERMISSION_SAVE = "PERMISSION_SAVE",
-    PLANNING_RECONDUCTION_END = "PLANNING_RECONDUCTION_END",
-    PLANNING_RECONDUCTION_START = "PLANNING_RECONDUCTION_START",
     RECORD_DELETE = "RECORD_DELETE",
     RECORD_SAVE = "RECORD_SAVE",
     TASKS_DELETE = "TASKS_DELETE",
@@ -544,6 +617,11 @@ export type Pagination = {
     limit: Scalars['Int']['input'];
     offset: Scalars['Int']['input'];
 };
+export type PartialAutomationRuleTriggerInput = {
+    eventAction?: InputMaybe<AutomationRuleEventAction>;
+    eventTopic?: InputMaybe<EventTopicInput>;
+    synchronous?: InputMaybe<Scalars['Boolean']['input']>;
+};
 export type PermissionActionInput = {
     allowed?: InputMaybe<Scalars['Boolean']['input']>;
     name: PermissionsActions;
@@ -724,26 +802,6 @@ export type RecordsPagination = {
     limit: Scalars['Int']['input'];
     offset?: InputMaybe<Scalars['Int']['input']>;
 };
-export type ReportFramingAttributeFilterItemInput = {
-    attributeId: Scalars['String']['input'];
-    values: Array<ReportFramingAttributeFilterValueItemInput>;
-    withEmptyValues?: InputMaybe<Scalars['Boolean']['input']>;
-};
-export type ReportFramingAttributeFilterValueItemInput = {
-    formattedValue?: InputMaybe<Scalars['String']['input']>;
-    rawValue: Scalars['String']['input'];
-};
-export type ReportFramingContentInput = {
-    filters?: InputMaybe<ReportFramingFiltersInput>;
-};
-export type ReportFramingFiltersInput = {
-    /**  only for excel header filter display  */
-    attributes?: InputMaybe<Array<ReportFramingAttributeFilterItemInput>>;
-    campaigns?: InputMaybe<Array<RecordFilterInput>>;
-    categories?: InputMaybe<Array<Scalars['String']['input']>>;
-    categoryStatus?: InputMaybe<Array<Scalars['String']['input']>>;
-    search?: InputMaybe<Scalars['String']['input']>;
-};
 export type SaveValueBulkMappingInput = {
     dependenciesFilters?: InputMaybe<Array<InputMaybe<RecordFilterInput>>>;
     values: Array<SaveValueBulkMappingValueInput>;
@@ -815,18 +873,12 @@ export declare enum TaskStatus {
 }
 export declare enum TaskType {
     EXPORT = "EXPORT",
-    FRAMING_REPORT = "FRAMING_REPORT",
     IMPORT_CONFIG = "IMPORT_CONFIG",
     IMPORT_DATA = "IMPORT_DATA",
     INDEXATION = "INDEXATION",
     PURGE_MULTIPLE_VALUES = "PURGE_MULTIPLE_VALUES",
-    RENEW_CAMPAIGNS = "RENEW_CAMPAIGNS",
     SAVE_VALUE_BULK = "SAVE_VALUE_BULK"
 }
-export type ThematicToRenew = {
-    campaignId: Scalars['String']['input'];
-    thematicId: Scalars['String']['input'];
-};
 export declare enum TreeBehavior {
     files = "files",
     standard = "standard"
@@ -892,6 +944,7 @@ export type UpdateAutomationRuleInput = {
     description?: InputMaybe<Scalars['SystemTranslationOptional']['input']>;
     id: Scalars['ID']['input'];
     label?: InputMaybe<Scalars['SystemTranslation']['input']>;
+    trigger?: InputMaybe<PartialAutomationRuleTriggerInput>;
 };
 export type UploadFiltersInput = {
     uid?: InputMaybe<Scalars['String']['input']>;
@@ -1083,7 +1136,7 @@ export type MeQuery = {
     } | null;
 };
 export type GetAutomationRulesQueryVariables = Exact<{
-    [key: string]: never;
+    filters?: InputMaybe<AutomationRulesFiltersInput>;
 }>;
 export type GetAutomationRulesQuery = {
     automationRules: {
@@ -1096,6 +1149,13 @@ export type GetAutomationRulesQuery = {
             createdBy: string;
             modifiedAt: number;
             modifiedBy: string;
+            trigger: {
+                synchronous: boolean;
+                eventAction: AutomationRuleEventAction;
+                eventTopic?: {
+                    library?: string | null;
+                } | null;
+            };
         }>;
     };
 };
@@ -1107,6 +1167,13 @@ export type CreateAutomationRuleMutation = {
         id: string;
         label: any;
         modifiedAt: number;
+        trigger: {
+            synchronous: boolean;
+            eventAction: AutomationRuleEventAction;
+            eventTopic?: {
+                library?: string | null;
+            } | null;
+        };
     };
 };
 export type UpdateAutomationRuleMutationVariables = Exact<{
@@ -1119,6 +1186,13 @@ export type UpdateAutomationRuleMutation = {
         description?: any | null;
         active: boolean;
         modifiedAt: number;
+        trigger: {
+            synchronous: boolean;
+            eventAction: AutomationRuleEventAction;
+            eventTopic?: {
+                library?: string | null;
+            } | null;
+        };
     };
 };
 export type GetRecordsLinkValuesPropertyQueryVariables = Exact<{

package/apps/core/src/__tests__/e2e/api/e2eUtils.d.ts

@@ -104,13 +104,6 @@ export declare const nonAdminUserSdk: {
 };
 export declare function makeGraphQlCall(query: string | FormData, options?: IMakeGraphQlCallOptions): Promise<any>;
 export declare function importFileGraphQlCall(query: string, filePath: string, sheets?: any): Promise<any>;
-export declare function gqlSaveLibrary(id: string, label: string, additionalAttributes?: string[], settings?: string, recordIdentityConf?: {
-    label: string;
-    subLabel?: string;
-    preview?: string;
-    color?: string;
-    treeColorPreview?: string;
-}): Promise<any>;
 export declare function gqlSaveApplication(id: string, label: string, endpoint: string): Promise<any>;
 export declare function gqlSaveAttribute(params: {
     id: string;

package/apps/core/src/__tests__/integration/domain/automation/pipelineExecutor.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,21 +1,48 @@
-import { type ISystemTranslation } from './systemTranslation';
+import { type EventAction, type IDbPayload } from '@leav/utils';
 export type IAutomationRule = ICoreEntity & {
+    createdAt: number;
+    createdBy: string;
+    modifiedAt: number;
+    modifiedBy: string;
     id: string;
-    label: ISystemTranslation;
-    description?: ISystemTranslation;
+    label: string;
+    description?: string;
     active: boolean;
-    createdAt?: number;
-    createdBy?: string;
-    modifiedAt?: number;
-    modifiedBy?: string;
+    trigger: AutomationRuleTrigger;
+    pipeline: AutomationRulePipeline;
 };
 export type ICreateAutomationRule = {
-    label: ISystemTranslation;
-    description?: ISystemTranslation;
+    label: string;
+    description?: string;
+    trigger: AutomationRuleTrigger;
 };
 export type IUpdateAutomationRule = {
     id: string;
-    label?: ISystemTranslation;
-    description?: ISystemTranslation;
+    label?: string;
+    description?: string;
     active?: boolean;
+    trigger?: Partial<AutomationRuleTrigger>;
+};
+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;
+};
+export type AutomationRulePipeline = {
+    steps: AutomationRulePipelineStep[];
+};
+export declare enum AutomationRuleActions {
+    LOG = "log",
+    CONDITION = "condition",
+    ERROR = "error"
+}
+export type AutomationRulePipelineStep = {
+    type: AutomationRuleActions | string;
+    name?: string;
+    params: Record<string, unknown>;
 };

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

@@ -35,6 +35,10 @@ export interface IConfig {
     pluginsPath: string[];
     bugsnag: IBugsnag;
     matomo: IMatomo;
+    automation: IAutomation;
+}
+export interface IAutomation {
+    enable: boolean;
 }
 export declare enum CoreMode {
     SERVER = "server",

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

@@ -1,17 +1,22 @@
 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';
 export type ICoreImportApp = IGraphqlAppModule;
-interface IDeps {
+interface IAutomationAppDeps {
     'core.domain.automation': IAutomationDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
 }
 export interface IGetAutomationRulesArgs {
     filters?: ICoreEntityFilterOptions & {
-        id: string;
-        active: boolean;
+        active?: boolean;
+        synchronous?: boolean;
+        eventAction?: IAutomationRule['trigger']['eventAction'];
+        eventTopic?: IAutomationRule['trigger']['eventTopic'];
     };
     pagination?: IPaginationParams;
     sort?: ISortParams;
 }
-export default function ({ 'core.domain.automation': automationDomain }: IDeps): ICoreImportApp;
+export default function ({ 'core.domain.automation': automationDomain, 'core.domain.eventsManager': eventsManagerDomain, }: IAutomationAppDeps): ICoreImportApp;
 export {};

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

@@ -2,7 +2,8 @@ import { type InitQueryContextFunc } from '../helpers/initQueryContext';
 import { type IEventsManagerDomain } from '../../domain/eventsManager/eventsManagerDomain';
 import { type IConfig } from '../../_types/config';
 import { type IAppModule } from '../../_types/shared';
-export type IEventsManagerApp = IAppModule;
+import { type IGraphqlAppModule } from '../graphql/graphqlApp';
+export type IEventsManagerApp = IAppModule & IGraphqlAppModule;
 interface IDeps {
     'core.domain.eventsManager': IEventsManagerDomain;
     'core.app.helpers.initQueryContext': InitQueryContextFunc;

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { type IAutomationAction } from '../types';
+declare const conditionActionParamsSchema: z.ZodObject<{
+    result: z.ZodBoolean;
+}, z.core.$strip>;
+export type ConditionActionParams = z.infer<typeof conditionActionParamsSchema>;
+export default function (): 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,3 @@
+export { default as condition } from './conditionAction';
+export { default as error } from './errorAction';
+export { default as log } from './logAction';

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<{
+        error: "error";
+        info: "info";
+        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/automationDomain.d.ts

@@ -1,13 +1,18 @@
-import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule } from '../../_types/automation';
+import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule, type AutomationRulesEventTopic, type AutomationRuleEventAction } from '../../_types/automation';
 import { type IList } from '../../_types/list';
 import { type IQueryInfos } from '../../_types/queryInfos';
 import { type IGetCoreEntitiesParams } from '../../_types/shared';
 import { type IAutomationRuleRepo } from '../../infra/automation/automationRuleRepo';
 import { type IAdminPermissionDomain } from '../permission/adminPermissionDomain';
 import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type IConfig } from '../../_types/config';
+import { type IPipelineExecutor } from './pipelineExecutor';
 export interface IGetAutomationRulesParams extends IGetCoreEntitiesParams {
     filters?: ICoreEntityFilterOptions & {
         active?: boolean;
+        synchronous?: boolean;
+        eventAction?: AutomationRuleEventAction;
+        eventTopic?: AutomationRulesEventTopic;
     };
 }
 export interface IAutomationDomain {
@@ -23,10 +28,16 @@ export interface IAutomationDomain {
         rule: IUpdateAutomationRule;
         ctx: IQueryInfos;
     }): Promise<IAutomationRule>;
+    triggerRules(event: {
+        action: AutomationRuleEventAction;
+        topic?: AutomationRulesEventTopic;
+    }, synchronous: boolean, ctx: IQueryInfos): Promise<void>;
 }
 export interface IAutomationDomainDeps {
     'core.domain.permission.admin': IAdminPermissionDomain;
     'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.automation.pipelineExecutor': IPipelineExecutor;
     'core.infra.automation.rule': IAutomationRuleRepo;
+    config: IConfig;
 }
-export default function ({ 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.infra.automation.rule': automationRuleRepo, }: IAutomationDomainDeps): IAutomationDomain;
+export default function ({ 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.automation.pipelineExecutor': pipelineExecutor, 'core.infra.automation.rule': automationRuleRepo, config, }: IAutomationDomainDeps): IAutomationDomain;

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/index.d.ts

@@ -1 +1,2 @@
 export { default } from './automationDomain';
+export { default as pipelineExecutor } from './pipelineExecutor';

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

@@ -0,0 +1,16 @@
+import { type AwilixContainer } from 'awilix';
+import { type AutomationRuleTrigger, type AutomationRulePipeline } from '../../_types/automation';
+import { type IAutomationAction } from './types';
+import { type IQueryInfos } from '../../_types/queryInfos';
+export type AutomationPipelineToExecute = AutomationRulePipeline & {
+    ruleId: string;
+    trigger: AutomationRuleTrigger;
+};
+export interface IPipelineExecutor {
+    getAvailableActions(): IAutomationAction[];
+    executePipeline(pipelineExec: AutomationPipelineToExecute, ctx: IQueryInfos): Promise<boolean>;
+}
+export interface IPipelineExecutorDeps {
+    'core.depsManager': AwilixContainer;
+}
+export default function ({ 'core.depsManager': depsManager }: IPipelineExecutorDeps): IPipelineExecutor;

package/apps/core/src/domain/automation/pipelineExecutor.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+import { type ZodObject } from 'zod';
+import { type AutomationRuleActions, type AutomationRuleTrigger } from '../../_types/automation';
+import { type IQueryInfos } from '../../_types/queryInfos';
+export declare enum ActionExecutionResultStatus {
+    CONTINUE = "continue",
+    STOP = "stop"
+}
+export type IActionExecutionResult = {
+    status: ActionExecutionResultStatus.CONTINUE;
+} | {
+    status: ActionExecutionResultStatus.STOP;
+    reason?: string;
+};
+export type IAutomationPipelineExecutionState = {
+    readonly trigger: AutomationRuleTrigger;
+};
+export interface IAutomationAction<Params = unknown> {
+    readonly type: AutomationRuleActions | string;
+    readonly paramsSchema: ZodObject<any>;
+    validateParams?: (params: Params) => Promise<void>;
+    execute(params: Params, state: IAutomationPipelineExecutionState, ctx: IQueryInfos): Promise<IActionExecutionResult | void>;
+}

package/apps/core/src/domain/record/helpers/createRecord.d.ts

@@ -4,6 +4,7 @@ import { type IRecordRepo } from '../../../infra/record/recordRepo';
 import { type IQueryInfos } from '../../../_types/queryInfos';
 import { type IRecord } from '../../../_types/record';
 import { type ICreateRecordValueError } from '../_types';
+import { type IAutomationDomain } from '../../automation/automationDomain';
 export type IPreCreateRecordCallback = () => Promise<ICreateRecordValueError[]>;
 export type CreateRecordHelper = (params: {
     library: string;
@@ -14,6 +15,7 @@ interface IDeps {
     'core.domain.eventsManager': IEventsManagerDomain;
     'core.domain.permission.library': ILibraryPermissionDomain;
     'core.infra.record': IRecordRepo;
+    'core.domain.automation': IAutomationDomain;
 }
-export default function ({ 'core.domain.eventsManager': eventsManager, 'core.domain.permission.library': libraryPermissionDomain, 'core.infra.record': recordRepo, }: IDeps): CreateRecordHelper;
+export default function ({ 'core.domain.eventsManager': eventsManager, 'core.domain.permission.library': libraryPermissionDomain, 'core.infra.record': recordRepo, 'core.domain.automation': automationDomain, }: IDeps): CreateRecordHelper;
 export {};