@aristid/leav-types 1.13.0 → 1.14.0-099d7b51

package/CLAUDE.md

@@ -15,8 +15,8 @@ depuis `apps/core`, destinée aux **développeurs de plugins** qui étendent le
 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
+- **`next`** — à chaque push sur `develop`
+- **`latest`** — sur les releases taguées
 
 ```bash
 # Commande de génération (lancée par le CI)

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

@@ -1,5 +1,5 @@
 export declare let instanceId: string;
-export declare let coreMode: string;
+export declare let coreModes: string[];
 export declare namespace server {
     let host: string;
     let port: number;
@@ -297,5 +297,9 @@ export declare let pluginsPath: string[];
 export declare namespace automation {
     let enable_7: boolean;
     export { enable_7 as enable };
+    export namespace cache {
+        let enable_8: boolean;
+        export { enable_8 as enable };
+    }
 }
 export { debug_2 as debug, _export as export, _import as import };

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

@@ -93,4 +93,8 @@ export namespace applications {
 export namespace automation {
     let enable_3: boolean;
     export { enable_3 as enable };
+    export namespace cache {
+        let enable_4: boolean;
+        export { enable_4 as enable };
+    }
 }

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

@@ -27,13 +27,18 @@ export type IUpdateAutomationRule = {
     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 AutomationRuleEventTopic = IDbPayload['topic'];
 export type AutomationRuleTrigger = {
     synchronous: boolean;
     eventAction: AutomationRuleEventAction;
-    eventTopic?: AutomationRulesEventTopic;
+    eventTopic?: AutomationRuleEventTopic;
 };
+export type AutomationRuleIndexEntry = Pick<IAutomationRule, 'id' | 'trigger'>;

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

@@ -2,7 +2,7 @@ import { type Options } from 'amqplib';
 import { type IKeyValue } from './shared';
 import { type PermissionsActions, type AdminPermissionsActions, type ApplicationPermissionsActions, type AttributePermissionsActions, type LibraryPermissionsActions, type PermissionTypes, type RecordAttributePermissionsActions, type RecordPermissionsActions, type TreeNodePermissionsActions, type TreePermissionsActions, type AttributeDependentValuesPermissionsActions } from './permissions';
 export interface IConfig {
-    coreMode: CoreMode;
+    coreModes: CoreMode[];
     server: IServer;
     db: IDb;
     diskCache: IDiskCache;
@@ -39,6 +39,10 @@ export interface IConfig {
 }
 export interface IAutomation {
     enable: boolean;
+    cache: IAutomationCache;
+}
+export interface IAutomationCache {
+    enable: boolean;
 }
 export declare enum CoreMode {
     SERVER = "server",
@@ -48,9 +52,21 @@ export declare enum CoreMode {
     TASKS_MANAGER_MASTER = "tasksManager:master",
     TASKS_MANAGER_WORKER = "tasksManager:worker",
     LOGS_COLLECTOR = "logsCollector",
-    E2E_PLAYWRIGHT = "e2ePlaywright",
-    CLI = "cli"
+    /**
+     * Default, to do db migration, or import ...
+     */
+    CLI = "cli",
+    /**
+     * Alias for [
+     *   CoreMode.SERVER,
+     *   CoreMode.INDEXATION_MANAGER,
+     *   CoreMode.TASKS_MANAGER_MASTER,
+     *   CoreMode.TASKS_MANAGER_WORKER,
+     * ]
+     */
+    E2E_PLAYWRIGHT = "e2ePlaywright"
 }
+export declare const CORE_MODES_E2E_PLAYWRIGHT: CoreMode[];
 export interface IServer {
     host: string;
     port: number;

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

@@ -60,6 +60,7 @@ export declare enum Errors {
     INVALID_VALUES_VERSIONS_SETTINGS_BAD_NODE_ID = "INVALID_VALUES_VERSIONS_SETTINGS_BAD_NODE_ID",
     INVALID_VARIABLE_FUNCTION = "INVALID_VARIABLE_FUNCTION",
     INVALID_VERSION = "INVALID_VERSION",
+    INVALID_VIEW_V2_INPUT = "INVALID_VIEW_V2_INPUT",
     LIBRARY_FORBIDDEN_AS_CHILD = "LIBRARY FORBIDDEN AS CHILD",
     METADATA_PERMISSION_ERROR = "METADATA_PERMISSION_ERROR",
     MISSING_ACTION_PREFIX = "MISSING_ACTION_PREFIX",

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

@@ -5,6 +5,7 @@ import { type PluginRegisterRoute } from './endpoint';
 import { type AuthPostOidcLoginCallback } from './auth';
 import { type RegisterCronTask } from './cronTask';
 import { type ITRPCRouterFactory } from '../app/trpc/trpcApp';
+import { type IAutomationAction } from '../domain/automation/actions/_types';
 export interface IExtensionPoints {
     [name: string]: (...args: any[]) => void;
 }
@@ -22,6 +23,7 @@ export interface IExtensionPointsFunctions extends IExtensionPoints {
     registerPermissionActions: (type: PermissionTypes, actions: string[], applyOn?: string[]) => void;
     registerEventActions: (actions: string[], prefix: string) => void;
     registerActions: (actions: IActionsListFunction[]) => void;
+    registerAutomationAction: <P = Record<string, unknown>>(action: IAutomationAction<P>) => void;
     registerTaskTypes: (types: string[]) => void;
     registerStart: (fct: () => Promise<void>) => void;
     /**

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

@@ -0,0 +1,7 @@
+import { type GlobalMeta } from 'zod';
+export type ZodMetaUISchema = GlobalMeta & {
+    ui?: {
+        title?: string;
+        placeholder?: string;
+    };
+};

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

@@ -0,0 +1,91 @@
+import { type SortOrder } from './list';
+import { type AttributeCondition, type TreeCondition } from './record';
+import { type ISystemTranslation } from './systemTranslation';
+export declare enum ViewV2Types {
+    LIST = "list",
+    CARDS = "cards",
+    TIMELINE = "timeline"
+}
+export interface IViewV2DisplayAttribute {
+    attributeId: string;
+    visible: boolean;
+}
+export interface IViewV2Display {
+    type: ViewV2Types;
+    attributes: IViewV2DisplayAttribute[];
+}
+export interface IViewV2ValuesVersion {
+    [treeId: string]: string;
+}
+export interface IViewV2Filter {
+    pinned: boolean;
+    attributes: string[];
+    values: Array<string | null>;
+    condition: AttributeCondition | TreeCondition;
+}
+export interface IViewV2Sort {
+    attributes: string[];
+    order: SortOrder;
+}
+/**
+ * User-facing fields of a view v2 with their natural required/optional cardinality.
+ * Source of truth for both the stored entity and the create/update inputs — every other
+ * shape in this file is derived from it.
+ */
+interface IViewV2UserFields {
+    library: string;
+    label: ISystemTranslation;
+    display: IViewV2Display;
+    shared: boolean;
+    filters: IViewV2Filter[];
+    sorts: IViewV2Sort[];
+    valuesVersions?: IViewV2ValuesVersion | null;
+}
+/**
+ * Server-managed fields, populated by the domain layer.
+ */
+interface IViewV2ServerFields {
+    id: string;
+    created_by: string;
+    created_at: number;
+    modified_at: number;
+}
+/**
+ * Stored view v2 entity, as persisted in ArangoDB and returned by the domain.
+ */
+export type IViewV2 = IViewV2UserFields & IViewV2ServerFields;
+/**
+ * Domain create input: user fields, with `columns` made optional (the domain
+ * defaults it to `[]`).
+ */
+export type IViewV2CreateInput = IViewV2UserFields;
+/**
+ * Domain update input: only `id` is mandatory; every other user field is optional
+ * and only the provided ones are updated.
+ */
+export type IViewV2UpdateInput = Pick<IViewV2ServerFields, 'id'> & Partial<IViewV2UserFields>;
+export interface IViewV2ValuesVersionForGraphql {
+    treeId: string;
+    treeNode: {
+        id: string;
+    };
+}
+/**
+ * GraphQL-shaped create input: same as the domain input but `valuesVersions` arrives as
+ * an array of `{treeId, treeNode}` pairs.
+ */
+export type IViewV2CreateInputFromGraphQL = Omit<IViewV2CreateInput, 'valuesVersions'> & {
+    valuesVersions?: IViewV2ValuesVersionForGraphql[];
+};
+/**
+ * GraphQL-shaped update input: same as the domain input with array-shaped `valuesVersions`.
+ */
+export type IViewV2UpdateInputFromGraphQL = Omit<IViewV2UpdateInput, 'valuesVersions'> & {
+    valuesVersions?: IViewV2ValuesVersionForGraphql[];
+};
+export interface IViewV2FilterOptions extends ICoreEntityFilterOptions {
+    created_by?: string;
+    library?: string;
+    type?: ViewV2Types;
+}
+export {};

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

@@ -1,14 +1,15 @@
-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 IAutomationTriggers } from '../../domain/automation/triggers/automationTriggers';
 import { type IAutomationTriggersRegistry } from '../..//domain/automation/triggers/automationTriggersRegistry';
-export type ICoreImportApp = IGraphqlAppModule;
+import { type IAutomationActionsRegistry } from '../../domain/automation/automationActionsRegistry';
+import { type IAppModule } from '../../_types/shared';
+import { type IGraphqlAppModule } from '../graphql/graphqlApp';
+export type ICoreAutomationApp = IAppModule & IGraphqlAppModule;
 interface IAutomationAppDeps {
     'core.domain.automation': IAutomationDomain;
-    'core.domain.automation.triggers': IAutomationTriggers;
     'core.domain.automation.triggers.registry': IAutomationTriggersRegistry;
+    'core.domain.automation.actionsRegistry': IAutomationActionsRegistry;
 }
 export interface IGetAutomationRulesArgs {
     filters?: ICoreEntityFilterOptions & {
@@ -20,5 +21,5 @@ export interface IGetAutomationRulesArgs {
     pagination?: IPaginationParams;
     sort?: ISortParams;
 }
-export default function ({ 'core.domain.automation': automationDomain, 'core.domain.automation.triggers': automationTriggers, 'core.domain.automation.triggers.registry': automationTriggersRegistry, }: IAutomationAppDeps): ICoreImportApp;
+export default function ({ 'core.domain.automation': automationDomain, 'core.domain.automation.triggers.registry': automationTriggersRegistry, 'core.domain.automation.actionsRegistry': automationActionsRegistry, }: IAutomationAppDeps): ICoreAutomationApp;
 export {};

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

@@ -24,4 +24,5 @@ export { default as userData } from './userDataApp';
 export { default as value } from './valueApp';
 export { default as versionProfile } from './versionProfileApp/versionProfileApp';
 export { default as view } from './viewApp';
+export { default as viewV2 } from './viewV2App';
 export { default as discussion } from './discussionApp';

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

@@ -0,0 +1,14 @@
+import { type IAttributeDomain } from '../../domain/attribute/attributeDomain';
+import { type IRecordDomain } from '../../domain/record/recordDomain';
+import { type IViewV2Domain } from '../../domain/viewV2/viewV2Domain';
+import { type IUtils } from '../../utils/utils';
+import { type IGraphqlAppModule } from '../graphql/graphqlApp';
+interface IDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.record': IRecordDomain;
+    'core.domain.viewV2': IViewV2Domain;
+    'core.utils': IUtils;
+}
+export type IViewV2App = IGraphqlAppModule;
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.domain.viewV2': viewV2Domain, 'core.domain.record': recordDomain, 'core.utils': utils, }: IDeps): IViewV2App;
+export {};

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

@@ -1,17 +1,25 @@
 import { type ZodObject } from 'zod';
-import { type IAutomationPipelineExecutionState } from '../pipeline/_types';
+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"
+    MODIFY_ATTRIBUTE = "modifyAttribute",
+    NOTIFICATION = "notification"
 }
-export interface IAutomationAction<Params = unknown> {
+export type AutomationPipelineStepValidation<Params = Record<string, unknown>> = {
+    readonly step: AutomationRulePipelineStep<Params>;
+    readonly stepIndex: number;
+    readonly trigger: AutomationRuleTrigger;
+    readonly precedingStepsByExecOrder: AutomationRulePipelineStep[];
+};
+export interface IAutomationAction<Params = Record<string, unknown>> {
     readonly type: AutomationRuleActions | string;
     readonly paramsSchema: ZodObject<any>;
-    validateParams?: (params: Params) => Promise<void>;
+    validateStep?: (params: AutomationPipelineStepValidation<Params>, ctx: IQueryInfos) => Promise<void>;
     execute(params: Params, state: IAutomationPipelineExecutionState, ctx: IQueryInfos): Promise<IActionExecutionResult | void>;
 }
 export declare enum ActionExecutionResultStatus {

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

@@ -1,8 +1,12 @@
 import { z } from 'zod';
 import { type IAutomationAction } from './_types';
+import { type IJexlAutomation } from '../jexl/jexlAutomation';
 declare const conditionActionParamsSchema: z.ZodObject<{
-    result: z.ZodBoolean;
+    expression: z.ZodString;
 }, z.core.$strip>;
 export type ConditionActionParams = z.infer<typeof conditionActionParamsSchema>;
-export default function (): IAutomationAction<ConditionActionParams>;
+interface IConditionActionDeps {
+    'core.domain.automation.jexl': IJexlAutomation;
+}
+export default function ({ 'core.domain.automation.jexl': jexlAutomation, }: IConditionActionDeps): IAutomationAction<ConditionActionParams>;
 export {};

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

@@ -3,3 +3,4 @@ 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

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

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

@@ -2,6 +2,7 @@ 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<{
@@ -13,6 +14,7 @@ export type ModifyAttributeActionParams = z.infer<typeof modifyAttributeActionPa
 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, }: IDeps): IAutomationAction<ModifyAttributeActionParams>;
+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,17 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+import { type INotificationDomain } from '../../notification/notificationDomain';
+import { type IJexlAutomation } from '../jexl/jexlAutomation';
+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.automation.jexl': IJexlAutomation;
+    'core.domain.notification': INotificationDomain;
+}
+export default function ({ 'core.domain.automation.jexl': jexlAutomation, 'core.domain.notification': notification, }: INotificationActionDeps): IAutomationAction<NotificationActionParams>;
+export {};

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

@@ -2,6 +2,7 @@ import { type AwilixContainer } from 'awilix';
 import { type IAutomationAction, type AutomationRuleActions } from './actions/_types';
 export interface IAutomationActionsRegistry {
     getAction(type: AutomationRuleActions | string): IAutomationAction | undefined;
+    registerAction(actions: IAutomationAction): void;
     listAvailableActions(): IAutomationAction[];
 }
 export interface IAutomationActionsRegistryDeps {

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

@@ -1,4 +1,4 @@
-import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule, type AutomationRulesEventTopic, type AutomationRuleEventAction } from '../../_types/automation';
+import { type ICreateAutomationRule, type IAutomationRule, type IUpdateAutomationRule, type AutomationRuleEventTopic, 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';
@@ -7,20 +7,24 @@ 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 IAutomationRulesCache } from './automationRulesCache';
 import { type IAutomationTriggers } from './triggers/automationTriggers';
-import { type AutomationTriggerDef } from './triggers/_types';
+import { type IAutomationActionsRegistry } from './automationActionsRegistry';
+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?: AutomationRuleEventAction;
-        eventTopic?: AutomationRulesEventTopic;
+        eventTopic?: AutomationRuleEventTopic;
     };
 }
 interface ITriggerRulesParams {
     event: {
-        action: IAutomationRule['trigger']['eventAction'];
-        topic?: IAutomationRule['trigger']['eventTopic'];
+        action: AutomationRuleEventAction;
+        topic?: AutomationRuleEventTopic;
     };
     synchronous: boolean;
     ctx: IQueryInfos;
@@ -30,6 +34,14 @@ export interface IAutomationDomain {
         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;
@@ -43,17 +55,18 @@ export interface IAutomationDomain {
         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.domain.automation.rulesCache': IAutomationRulesCache;
     'core.infra.automation.rule': IAutomationRuleRepo;
+    'core.domain.automation.actionsRegistry': IAutomationActionsRegistry;
     config: IConfig;
 }
-export default function ({ 'core.domain.automation.triggers': automationTriggers, 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.automation.pipeline': pipelineDomain, '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.domain.automation.rulesCache': automationRulesCache, 'core.infra.automation.rule': automationRuleRepo, 'core.domain.automation.actionsRegistry': automationActionsRegistry, config, }: IAutomationDomainDeps): IAutomationDomain;
 export {};

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

@@ -0,0 +1,66 @@
+import { type AutomationRuleEventAction, type AutomationRuleEventTopic, type IAutomationRule } from '../../_types/automation';
+import { type IConfig } from '../../_types/config';
+import { type IQueryInfos } from '../../_types/queryInfos';
+import { type IAutomationRuleRepo } from '../../infra/automation/automationRuleRepo';
+import { type ICachesService } from '../../infra/cache/cacheService';
+/**
+ * Two-tier cache for automation rules, shared across every `core` replica
+ * via Redis.
+ *
+ * ## Structure
+ *
+ * 1. **Index** under the key `automation:rules:index` → `AutomationRuleIndexEntry[]`
+ *    (= `Pick<IAutomationRule, 'id' | 'trigger'>[]`). Holds the bare minimum
+ *    needed to decide which rules match an event (action, sync, topic).
+ *    Built on the ArangoDB side via a dedicated AQL projection
+ *    (`automationRuleRepo.getActiveAutomationRulesForCache`) — pipelines and
+ *    metadata never leave the Arango server.
+ *
+ * 2. **Per-rule cache** under `automation:rules:{ruleId}` → the full
+ *    `IAutomationRule` (pipeline included). Populated **lazily**: only a rule
+ *    that is actually matched by an event triggers the fetch + caching of its
+ *    full payload.
+ *
+ * ## Why this split
+ *
+ * Selecting which rules to execute only depends on `trigger`; the `pipeline`
+ * is only required when the rule actually runs. With a naive "full-list"
+ * cache, every event would load all pipelines (potentially large) to execute
+ * 0 to a handful of them. The lightweight index bounds the selection cost to
+ * an `{id, trigger}` payload × number of active rules; only the pipelines of
+ * matching rules are fetched.
+ *
+ * ## Targeted invalidation
+ *
+ * `invalidate(ruleId)` removes only `[INDEX_RULES_CACHE_KEY,
+ * ruleCacheKey(ruleId)]`. Other rules keep their Redis entry intact — their
+ * pipelines are not reloaded until a modification targets them. Relevant
+ * when an admin edits a single rule among dozens (the typical case).
+ *
+ * `invalidate()` without an argument performs a full wipe via the
+ * `RULES_CACHE_KEYS_PATTERN` glob (useful for tests and global admin purges).
+ *
+ * ## Lazy per-rule population (not eager)
+ *
+ * On an index rebuild, per-rule caches are NOT re-written. Otherwise,
+ * re-writing every rule on each modification would defeat the "preserve
+ * other rules" guarantee. Acceptable trade-off: if a matched rule has never
+ * been cached, `_loadRuleById` performs an extra repo fetch — the debt is
+ * amortized by subsequent hits.
+ */
+export declare const INDEX_RULES_CACHE_KEY = "automation:rules:index";
+export declare const RULES_CACHE_KEYS_PATTERN = "automation:rules:*";
+export declare const ruleCacheKey: (id: string) => string;
+export interface IAutomationRulesCache {
+    getRulesToTrigger(event: {
+        action: AutomationRuleEventAction;
+        topic?: AutomationRuleEventTopic;
+    }, synchronous: boolean, ctx: IQueryInfos): Promise<IAutomationRule[]>;
+    invalidate(ruleId?: string): Promise<void>;
+}
+export interface IAutomationRulesCacheDeps {
+    'core.infra.cache.cacheService': ICachesService;
+    'core.infra.automation.rule': IAutomationRuleRepo;
+    config: IConfig;
+}
+export default function ({ 'core.infra.cache.cacheService': cachesService, 'core.infra.automation.rule': automationRuleRepo, config, }: IAutomationRulesCacheDeps): IAutomationRulesCache;

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

@@ -1,7 +1,7 @@
-import { type AutomationRuleEventAction, type AutomationRulesEventTopic, type IAutomationRule } from '../../_types/automation';
+import { type AutomationRuleEventAction, type AutomationRuleEventTopic, 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;
+    topic?: AutomationRuleEventTopic;
 }, synchronous: boolean, ctx: IQueryInfos) => Promise<IAutomationRule[]>;

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

@@ -0,0 +1,21 @@
+import { AutomationRuleJsonSchemaFormType } from '../../../_types/automation';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IAutomationTriggersRegistry } from '../triggers/automationTriggersRegistry';
+import { type IAutomationActionsRegistry } from '../automationActionsRegistry';
+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;
+    'core.domain.automation.actionsRegistry': IAutomationActionsRegistry;
+}
+export declare const extractAndLiftDefs: (jsonSchema: RJSFSchema) => {
+    schema: RJSFSchema;
+    defs: Record<string, RJSFSchema>;
+};
+export default function ({ 'core.domain.automation.triggers.registry': automationTriggersRegistry, 'core.domain.automation.actionsRegistry': actionsRegistry, }: IAutomationJsonSchemaFormDomainDeps): IAutomationJsonSchemaFormDomain;
+export {};

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

@@ -0,0 +1,19 @@
+import { type i18n } from 'i18next';
+import { type UiSchema } from '@rjsf/utils';
+import { AutomationRuleJsonSchemaFormType } from '../../../_types/automation';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IAutomationTriggersRegistry } from '../triggers/automationTriggersRegistry';
+import { type IAutomationActionsRegistry } from '../automationActionsRegistry';
+export interface IAutomationUiJsonSchemaFormDomain {
+    getAutomationRuleUiJsonSchemaForm({ formType, ctx, }: {
+        formType: AutomationRuleJsonSchemaFormType;
+        ctx: IQueryInfos;
+    }): Promise<UiSchema>;
+}
+interface IAutomationUiJsonSchemaFormDomainDeps {
+    translator: i18n;
+    'core.domain.automation.triggers.registry': IAutomationTriggersRegistry;
+    'core.domain.automation.actionsRegistry': IAutomationActionsRegistry;
+}
+export default function ({ translator, 'core.domain.automation.triggers.registry': automationTriggersRegistry, 'core.domain.automation.actionsRegistry': actionsRegistry, }: 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,4 +1,6 @@
 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 rulesCache } from './automationRulesCache';
 export { default as triggers } from './triggers';

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

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

package/apps/core/src/domain/automation/jexl/jexlAutomation.d.ts

@@ -0,0 +1,16 @@
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IJexlDomain } from '../../jexl/jexlDomain';
+import { type IAutomationPipelineExecutionState } from '../pipeline/_types';
+import { type JexlRootContext, type JexlRecordContext } from '../../jexl/types';
+interface IDeps {
+    'core.domain.jexl': IJexlDomain;
+}
+type JexlAutomationContext = JexlRootContext<{
+    results: IAutomationPipelineExecutionState['results'];
+    currentRecord?: JexlRecordContext;
+}>;
+export interface IJexlAutomation extends Pick<IJexlDomain, 'eval' | 'validate'> {
+    buildAutomationContext: (executionState: IAutomationPipelineExecutionState, ctx: IQueryInfos) => JexlAutomationContext;
+}
+export default function ({ 'core.domain.jexl': jexlDomain }: IDeps): IJexlAutomation;
+export {};