@aristid/leav-types 1.12.0 → 1.13.0-0ceda52e

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

@@ -1,5 +1,5 @@
-import { type IAttributeDomain } from 'domain/attribute/attributeDomain';
-import { type ICalculationVariable } from 'domain/helpers/calculations/calculationVariable';
+import { type IAttributeDomain } from '../attribute/attributeDomain';
+import { type ICalculationVariable } from '../helpers/calculations/calculationVariable';
 import { type IActionsListFunction } from '../../_types/actionsList';
 interface IDeps {
     'core.domain.helpers.calculationVariable'?: ICalculationVariable;

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

@@ -1,7 +1,7 @@
-import { type IAttributeDomain } from 'domain/attribute/attributeDomain';
-import { type IValueDomain } from 'domain/value/valueDomain';
+import { type IAttributeDomain } from '../attribute/attributeDomain';
+import { type IValueDomain } from '../value/valueDomain';
 import { type IActionsListFunction } from '../../_types/actionsList';
-import { type IUtils } from 'utils/utils';
+import { type IUtils } from '../../utils/utils';
 interface IDeps {
     'core.domain.value'?: IValueDomain;
     'core.domain.attribute'?: IAttributeDomain;

package/apps/core/src/domain/apiKey/apiKeyDomain.d.ts

@@ -1,10 +1,10 @@
-import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
-import { type IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
+import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type IAdminPermissionDomain } from '../permission/adminPermissionDomain';
 import { type i18n } from 'i18next';
-import { type IApiKeyRepo } from 'infra/apiKey/apiKeyRepo';
-import { type IUtils } from 'utils/utils';
-import { type IApiKey, type IGetCoreApiKeysParams } from '_types/apiKey';
-import { type IQueryInfos } from '_types/queryInfos';
+import { type IApiKeyRepo } from '../../infra/apiKey/apiKeyRepo';
+import { type IUtils } from '../../utils/utils';
+import { type IApiKey, type IGetCoreApiKeysParams } from '../../_types/apiKey';
+import { type IQueryInfos } from '../../_types/queryInfos';
 import { type IList } from '../../_types/list';
 import { type IConfig } from '../../_types/config';
 export interface IApiKeyDomain {

package/apps/core/src/domain/application/applicationDomain.d.ts

@@ -1,11 +1,11 @@
-import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
-import { type IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
-import { type IUserDomain } from 'domain/user/userDomain';
+import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type IAdminPermissionDomain } from '../permission/adminPermissionDomain';
+import { type IUserDomain } from '../user/userDomain';
 import { type i18n } from 'i18next';
-import { type IApplicationRepo } from 'infra/application/applicationRepo';
-import { type IUtils } from 'utils/utils';
-import { type IConfig } from '_types/config';
-import { type IQueryInfos } from '_types/queryInfos';
+import { type IApplicationRepo } from '../../infra/application/applicationRepo';
+import { type IUtils } from '../../utils/utils';
+import { type IConfig } from '../../_types/config';
+import { type IQueryInfos } from '../../_types/queryInfos';
 import { type IApplication, type IApplicationModule, type IGetCoreApplicationsParams } from '../../_types/application';
 import { type IList } from '../../_types/list';
 import { type IAppStudioDomain } from './appStudioDomain';

package/apps/core/src/domain/application/helpers/getLibrarySystemPanels.d.ts

@@ -1,6 +1,6 @@
-import { type IApplication } from '_types/application';
+import { type IApplication } from '../../../_types/application';
 import { type i18n } from 'i18next';
-import { type IConfig } from '_types/config';
+import { type IConfig } from '../../../_types/config';
 export interface IGetLibrarySystemPanelsHelperDeps {
     translator: i18n;
     config: IConfig;

package/apps/core/src/domain/attribute/attributeDomain.d.ts

@@ -1,19 +1,19 @@
-import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
-import { type GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
-import { type IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
-import { type IVersionProfileDomain } from 'domain/versionProfile/versionProfileDomain';
-import { type IAttributeRepo } from 'infra/attribute/attributeRepo';
-import { type IFormRepo } from 'infra/form/formRepo';
-import { type ILibraryRepo } from 'infra/library/libraryRepo';
-import { type ITreeRepo } from 'infra/tree/treeRepo';
-import { type IUtils } from 'utils/utils';
-import { type ILibrary } from '_types/library';
-import { type IQueryInfos } from '_types/queryInfos';
+import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type GetCoreEntityByIdFunc } from '../helpers/getCoreEntityById';
+import { type IAdminPermissionDomain } from '../permission/adminPermissionDomain';
+import { type IVersionProfileDomain } from '../versionProfile/versionProfileDomain';
+import { type IAttributeRepo } from '../../infra/attribute/attributeRepo';
+import { type IFormRepo } from '../../infra/form/formRepo';
+import { type ILibraryRepo } from '../../infra/library/libraryRepo';
+import { type ITreeRepo } from '../../infra/tree/treeRepo';
+import { type IUtils } from '../../utils/utils';
+import { type ILibrary } from '../../_types/library';
+import { type IQueryInfos } from '../../_types/queryInfos';
 import { type ICachesService } from '../../infra/cache/cacheService';
 import { type IAttribute, type IGetCoreAttributesParams, type IGetCoreFormAttributesParams, type IOAllowedTypes } from '../../_types/attribute';
 import { type IList } from '../../_types/list';
 import { type IActionsListDomain } from '../actionsList/actionsListDomain';
-import { type IValidateHelper } from 'domain/helpers/validate';
+import { type IValidateHelper } from '../helpers/validate';
 export interface IAttributeDomain {
     getAttributeProperties({ id, ctx }: {
         id: string;

package/apps/core/src/domain/attribute/helpers/attributeALHelper.d.ts

@@ -1,4 +1,4 @@
-import { type IUtils } from 'utils/utils';
+import { type IUtils } from '../../../utils/utils';
 import { type ActionsListConfig } from '../../../_types/actionsList';
 import { type IAttribute, type IOAllowedTypes } from '../../../_types/attribute';
 declare const getAllowedInputTypes: (attribute: IAttribute) => IOAllowedTypes;

package/apps/core/src/domain/attribute/helpers/attributeValidationHelper.d.ts

@@ -1,9 +1,9 @@
-import { type IActionsListDomain } from 'domain/actionsList/actionsListDomain';
-import { type IVersionProfileDomain } from 'domain/versionProfile/versionProfileDomain';
-import { type IAttributeRepo } from 'infra/attribute/attributeRepo';
-import { type ITreeRepo } from 'infra/tree/treeRepo';
-import { type IUtils } from 'utils/utils';
-import { type IQueryInfos } from '_types/queryInfos';
+import { type IActionsListDomain } from '../../actionsList/actionsListDomain';
+import { type IVersionProfileDomain } from '../../versionProfile/versionProfileDomain';
+import { type IAttributeRepo } from '../../../infra/attribute/attributeRepo';
+import { type ITreeRepo } from '../../../infra/tree/treeRepo';
+import { type IUtils } from '../../../utils/utils';
+import { type IQueryInfos } from '../../../_types/queryInfos';
 import { type IAttribute } from '../../../_types/attribute';
 import { type ErrorFieldDetail } from '../../../_types/errors';
 export declare const validateAttributeData: (attrData: IAttribute, deps: {

package/apps/core/src/domain/attribute/helpers/ifLibraryJoinLinkAttribute.d.ts

@@ -1,7 +1,7 @@
 import { type IAttribute } from '../../../_types/attribute';
 import { type IQueryInfos } from '../../../_types/queryInfos';
-import { type IAttributeDomain } from 'domain/attribute/attributeDomain';
-import { type GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+import { type IAttributeDomain } from '../attributeDomain';
+import { type GetCoreEntityByIdFunc } from '../../helpers/getCoreEntityById';
 export type IfLibraryJoinLinkAttributeCallback<R> = (joinLibId: string, joinAttributeProps: IAttribute) => Promise<R>;
 export type IfLibraryJoinLinkAttribute = <R = unknown>(attributeProps: IAttribute, callback: IfLibraryJoinLinkAttributeCallback<R>, ctx: IQueryInfos) => Promise<R | void>;
 export interface IIfLibraryJoinLinkDeps {

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,12 @@
+import { z } from 'zod';
+import { type IAutomationAction } from './_types';
+import { type IJexlAutomation } from '../jexl/jexlAutomation';
+declare const conditionActionParamsSchema: z.ZodObject<{
+    expression: z.ZodString;
+}, z.core.$strip>;
+export type ConditionActionParams = z.infer<typeof conditionActionParamsSchema>;
+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/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,14 @@
+import { z } from 'zod';
+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.automation.jexl': IJexlAutomation;
+    config: IConfig;
+}
+export default function ({ 'core.domain.automation.jexl': jexlAutomation, config, }: 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,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

@@ -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

@@ -0,0 +1,74 @@
+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';
+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 IAutomationPipelineDomain } from './pipeline/pipeline';
+import { type IAutomationRulesCache } from './automationRulesCache';
+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?: AutomationRuleEventAction;
+        eventTopic?: AutomationRuleEventTopic;
+    };
+}
+interface ITriggerRulesParams {
+    event: {
+        action: AutomationRuleEventAction;
+        topic?: AutomationRuleEventTopic;
+    };
+    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;
+    }): Promise<IAutomationRule>;
+    updateAutomationRule({ rule, ctx }: {
+        rule: IUpdateAutomationRule;
+        ctx: IQueryInfos;
+    }): Promise<IAutomationRule>;
+    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.domain.automation.rulesCache': IAutomationRulesCache;
+    'core.infra.automation.rule': IAutomationRuleRepo;
+    config: IConfig;
+}
+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, 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

@@ -0,0 +1,7 @@
+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?: 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

@@ -0,0 +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 {};

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

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

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

@@ -0,0 +1,13 @@
+import { type AutomationPipelineExecution, type AutomationPipelineValidation } from '../pipeline/_types';
+import { type IEventsManagerDomain } from '../../eventsManager/eventsManagerDomain';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IAutomationActionsRegistry } from '../automationActionsRegistry';
+export interface IAutomationPipelineDomain {
+    executePipeline(pipelineExec: AutomationPipelineExecution, ctx: IQueryInfos): Promise<boolean>;
+    validatePipeline(pipelineToValidate: AutomationPipelineValidation, ctx: IQueryInfos): Promise<void>;
+}
+export interface IPipelineExecutorDeps {
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.automation.actionsRegistry': IAutomationActionsRegistry;
+}
+export default function ({ 'core.domain.eventsManager': eventsManager, 'core.domain.automation.actionsRegistry': actionsRegistry, }: IPipelineExecutorDeps): IAutomationPipelineDomain;

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

@@ -0,0 +1,3 @@
+import { type AutomationPipelineStepValidation } from '../actions/_types';
+import { type AutomationPipelineValidation } from './_types';
+export declare function pipelineStepValidation<Params>(pipelineToValidate: AutomationPipelineValidation, stepIndex: number): AutomationPipelineStepValidation<Params>;

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

@@ -0,0 +1,15 @@
+import { type AutomationRuleEventAction } from '../../../_types/automation';
+export declare enum AutomationTriggerDefTopics {
+    LIBRARY = "LIBRARY",
+    ATTRIBUTE = "ATTRIBUTE"
+}
+export declare enum AutomationTriggerDefSynchronicity {
+    SYNC = "SYNC",
+    ASYNC = "ASYNC",
+    BOTH = "BOTH"
+}
+export type AutomationTriggerDef = {
+    eventAction: AutomationRuleEventAction;
+    topics: AutomationTriggerDefTopics[];
+    synchronicity: AutomationTriggerDefSynchronicity;
+};