@aristid/leav-types 1.12.0-bfe263d1 → 1.12.0-c1e83ccc

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

@@ -105,6 +105,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 +234,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;
@@ -287,4 +291,8 @@ export declare namespace logsCollector {
     let queue: string;
 }
 export declare let pluginsPath: string[];
-export { debug_1 as debug, _export as export, _import as import };
+export declare namespace automation {
+    let enable_7: boolean;
+    export { enable_7 as enable };
+}
+export { debug_2 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/_types/automation.d.ts

@@ -1,10 +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;
-    createdAt?: number;
-    createdBy?: string;
-    modifiedAt?: number;
-    modifiedBy?: string;
+    label: string;
+    description?: string;
+    active: boolean;
+    trigger: AutomationRuleTrigger;
+    pipeline: AutomationRulePipeline;
+};
+export type ICreateAutomationRule = {
+    label: string;
+    description?: string;
+    trigger: AutomationRuleTrigger;
+};
+export type IUpdateAutomationRule = {
+    id: string;
+    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",
@@ -73,6 +77,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

@@ -28,6 +28,7 @@ export declare enum Errors {
     FORMAT_ERROR = "FORMAT_ERROR",
     IMMUTABLE_CORE_SYSTEM_ATTRIBUTE = "IMMUTABLE_CORE_SYSTEM_ATTRIBUTE",
     INVALID_ACTION_TYPE = "INVALID_ACTION_TYPE",
+    INVALID_ACTION_PARAMS = "INVALID_ACTION_PARAMS",
     INVALID_ATTRIBUTE_TYPE = "INVALID_ATTRIBUTE_TYPE",
     INVALID_ATTRIBUTE_FILTER_FORMAT = "INVALID_ATTRIBUTE_FILTER_FORMAT",
     INVALID_ATTRIBUTE_FOR_LIBRARY = "INVALID_ATTRIBUTE_FOR_LIBRARY",
@@ -91,6 +92,7 @@ export declare enum Errors {
     UNKNOWN_APPLICATION = "UNKNOWN_APPLICATION",
     UNKNOWN_ATTRIBUTE = "UNKNOWN_ATTRIBUTE",
     UNKNOWN_ATTRIBUTES = "UNKNOWN_ATTRIBUTES",
+    UNKNOWN_AUTOMATION_RULE = "UNKNOWN_AUTOMATION_RULE",
     UNKNOWN_ELEMENT = "UNKNOWN_ELEMENT",
     UNKNOWN_FORM = "UNKNOWN_FORM",
     UNKNOWN_FORM_ATTRIBUTES = "UNKNOWN_FORM_ATTRIBUTES",

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

@@ -9,6 +9,8 @@ import { type IValue } from './value';
 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/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
@@ -30,6 +32,10 @@ interface IDBPayloadDataMap {
     [EventAction.API_KEY_DELETE]: IApiKey;
     [EventAction.APP_SAVE]: IApplication;
     [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/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/attributeApp/attributeApp.d.ts

@@ -3,6 +3,7 @@ import { type IAttributeDomain } from '../../../domain/attribute/attributeDomain
 import { type ILibraryDomain } from '../../../domain/library/libraryDomain';
 import { type IPermissionDomain } from '../../../domain/permission/permissionDomain';
 import { type IAttributeDependentValuesPermissionDomain } from '../../../domain/permission/attributeDependentValuesPermissionDomain';
+import { type IfLibraryJoinLinkAttribute } from '../../../domain/attribute/helpers/ifLibraryJoinLinkAttribute';
 import { type IRecordDomain } from '../../../domain/record/recordDomain';
 import { type ITreeDomain } from '../../../domain/tree/treeDomain';
 import { type IVersionProfileDomain } from '../../../domain/versionProfile/versionProfileDomain';
@@ -12,6 +13,7 @@ import { type ICoreApp } from '../coreApp';
 export type ICoreAttributeApp = IGraphqlAppModule;
 interface IDeps {
     'core.domain.attribute': IAttributeDomain;
+    'core.domain.attribute.helpers.ifLibraryJoinLinkAttribute': IfLibraryJoinLinkAttribute;
     'core.domain.library': ILibraryDomain;
     'core.domain.record': IRecordDomain;
     'core.domain.tree': ITreeDomain;

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

@@ -1,16 +1,24 @@
 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/automationTriggers';
 export type ICoreImportApp = IGraphqlAppModule;
-interface IDeps {
+interface IAutomationAppDeps {
     'core.domain.automation': IAutomationDomain;
+    'core.domain.automation.triggers': IAutomationTriggers;
+    'core.domain.eventsManager': IEventsManagerDomain;
 }
 export interface IGetAutomationRulesArgs {
     filters?: ICoreEntityFilterOptions & {
-        id: string;
+        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.automation.triggers': automationTriggers, '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/app/core/filesManagerApp.d.ts

@@ -5,6 +5,7 @@ import { type IFilesManagerDomain } from '../../domain/filesManager/filesManager
 import { type ValidateRequestTokenFunc } from '../helpers/validateRequestToken';
 import { type IGraphqlAppModule } from '../graphql/graphqlApp';
 import { type IServerRouteAppModule } from '../../interface/server';
+import { type IRecordPermissionDomain } from '../../domain/permission/recordPermissionDomain';
 export interface IFilesManagerApp extends IGraphqlAppModule, IServerRouteAppModule {
     init(): Promise<void>;
 }
@@ -13,7 +14,8 @@ interface IDeps {
     'core.app.helpers.validateRequestToken': ValidateRequestTokenFunc;
     'core.domain.filesManager': IFilesManagerDomain;
     'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.permission.record': IRecordPermissionDomain;
     config: IConfig;
 }
-export default function ({ 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.validateRequestToken': validateRequestToken, 'core.domain.filesManager': filesManagerDomain, 'core.domain.eventsManager': eventsManager, config, }: IDeps): IFilesManagerApp;
+export default function ({ 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.validateRequestToken': validateRequestToken, 'core.domain.filesManager': filesManagerDomain, 'core.domain.eventsManager': eventsManager, 'core.domain.permission.record': recordPermissionDomain, config, }: IDeps): IFilesManagerApp;
 export {};

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

@@ -3,6 +3,7 @@ import { type IAttributeDomain } from '../../domain/attribute/attributeDomain';
 import { type IEventsManagerDomain } from '../../domain/eventsManager/eventsManagerDomain';
 import { type ILibraryDomain } from '../../domain/library/libraryDomain';
 import { type ILogDomain } from '../../domain/log/logDomain';
+import { type IAutomationDomain } from '../../domain/automation/automationDomain';
 import { type ITreeDomain } from '../../domain/tree/treeDomain';
 import { type IVersionProfileDomain } from '../../domain/versionProfile/versionProfileDomain';
 import { type IAppModule } from '../../_types/shared';
@@ -21,9 +22,10 @@ interface IDeps {
     'core.domain.value.helpers.formatLogValue': IFormatLogValueHelper;
     'core.domain.versionProfile': IVersionProfileDomain;
     'core.domain.application': IApplicationDomain;
+    'core.domain.automation': IAutomationDomain;
     'core.domain.record': IRecordDomain;
     translator: i18n;
     config: IConfig;
 }
-export default function ({ 'core.domain.log': logDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.library': libraryDomain, 'core.domain.attribute': attributeDomain, 'core.domain.tree': treeDomain, 'core.domain.value.helpers.formatLogValue': formatLogValue, 'core.domain.versionProfile': versionProfileDomain, 'core.domain.application': applicationDomain, 'core.domain.record': recordDomain, translator, config, }: IDeps): ICoreLogApp;
+export default function ({ 'core.domain.log': logDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.library': libraryDomain, 'core.domain.attribute': attributeDomain, 'core.domain.tree': treeDomain, 'core.domain.value.helpers.formatLogValue': formatLogValue, 'core.domain.versionProfile': versionProfileDomain, 'core.domain.application': applicationDomain, 'core.domain.automation': automationDomain, 'core.domain.record': recordDomain, translator, config, }: IDeps): ICoreLogApp;
 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/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<{
+        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/automationDomain.d.ts

@@ -1,14 +1,18 @@
-import { type IAutomationRule } 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';
-interface IGetAutomationRulesParams extends IGetCoreEntitiesParams {
+import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type IConfig } from '../../_types/config';
+import { type IPipelineExecutor } from './pipelineExecutor';
+export interface IGetAutomationRulesParams extends IGetCoreEntitiesParams {
     filters?: ICoreEntityFilterOptions & {
-        created_at?: number;
-        created_by?: string;
-        modified_at?: number;
-        modified_by?: string;
+        active?: boolean;
+        synchronous?: boolean;
+        eventAction?: AutomationRuleEventAction;
+        eventTopic?: AutomationRulesEventTopic;
     };
 }
 export interface IAutomationDomain {
@@ -16,9 +20,24 @@ export interface IAutomationDomain {
         params: IGetAutomationRulesParams;
         ctx: IQueryInfos;
     }): Promise<IList<IAutomationRule>>;
+    createAutomationRule({ rule, ctx }: {
+        rule: ICreateAutomationRule;
+        ctx: IQueryInfos;
+    }): Promise<IAutomationRule>;
+    updateAutomationRule({ rule, ctx }: {
+        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, }: IAutomationDomainDeps): IAutomationDomain;
-export {};
+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/automationTriggers.d.ts

@@ -0,0 +1,25 @@
+import { type AutomationRuleEventAction } from '../../_types/automation';
+import { type IQueryInfos } from '../../_types/queryInfos';
+/**
+ * This list of topic should match AutomationRulesEventTopic properties
+ */
+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;
+};
+export interface IAutomationTriggers {
+    getAutomationTriggers({ ctx }: {
+        ctx: IQueryInfos;
+    }): AutomationTriggerDef[];
+}
+export default function (): IAutomationTriggers;

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,3 @@
 export { default } from './automationDomain';
+export { default as pipelineExecutor } from './pipelineExecutor';
+export { default as triggers } from './automationTriggers';

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

@@ -0,0 +1,18 @@
+import { type AwilixContainer } from 'awilix';
+import { type AutomationRuleTrigger, type AutomationRulePipeline } from '../../_types/automation';
+import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+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;
+    'core.domain.eventsManager': IEventsManagerDomain;
+}
+export default function ({ 'core.depsManager': depsManager, 'core.domain.eventsManager': eventsManager, }: IPipelineExecutorDeps): IPipelineExecutor;

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

@@ -0,0 +1,37 @@
+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;
+    result?: unknown;
+} | {
+    status: ActionExecutionResultStatus.STOP;
+    reason?: string;
+};
+export type IAutomationPipelineExecutionResults = Record<string, unknown>;
+export type IAutomationPipelineExecutionState = {
+    readonly trigger: AutomationRuleTrigger;
+    readonly results: IAutomationPipelineExecutionResults;
+    readonly startDateMs: number;
+};
+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>;
+}
+export type IAutomationPipelineSuccess = {
+    readonly results: Record<string, unknown>;
+};
+export type IAutomationPipelineFailure = {
+    readonly results: Record<string, unknown | {
+        stack?: string;
+        message: string;
+        name: string;
+        [k: string]: unknown;
+    }>;
+};

package/apps/core/src/domain/discussion/discussionDomain.d.ts

@@ -6,6 +6,7 @@ import { type IValueDomain } from '../value/valueDomain';
 import { type IUserDomain } from '../user/userDomain';
 import { type i18n } from 'i18next';
 import { type IConfig } from '../../_types/config';
+import { type IEventsManagerDomain } from '../../domain/eventsManager/eventsManagerDomain';
 export interface IDiscussionDomain {
     postDiscussionComment(params: {
         params?: IPostDiscussionCommentParams;
@@ -17,7 +18,8 @@ export interface IDiscussionDomainDeps {
     'core.domain.record': IRecordDomain;
     'core.domain.value': IValueDomain;
     'core.domain.user': IUserDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
     translator: i18n;
     config: IConfig;
 }
-export default function ({ 'core.domain.notification': notificationDomain, 'core.domain.record': recordDomain, 'core.domain.value': valueDomain, 'core.domain.user': userDomain, translator, config, }: IDiscussionDomainDeps): IDiscussionDomain;
+export default function ({ 'core.domain.notification': notificationDomain, 'core.domain.record': recordDomain, 'core.domain.value': valueDomain, 'core.domain.user': userDomain, 'core.domain.eventsManager': eventsManagerDomain, translator, config, }: IDiscussionDomainDeps): IDiscussionDomain;

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

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

package/apps/core/src/domain/jexl/jexlDomain.d.ts

@@ -0,0 +1,18 @@
+import { type IValueDomain } from '../value/valueDomain';
+import { type IQueryInfos } from '../../_types/queryInfos';
+import { type IRecord } from '../../_types/record';
+import { type IValue } from '../../_types/value';
+import { type ITreeNode } from '../../_types/tree';
+import { type JexlContext, type JexlRecordContext, type JexlRootContext, type JexlTreeNodeContext, type JexlValueContext } from './types';
+interface IDeps {
+    'core.domain.value': IValueDomain;
+}
+export interface IJexlDomain {
+    eval<Ctx extends JexlContext>(expression: string, context?: Ctx): Promise<any>;
+    buildRootContext: <T>(contextData: T, ctx: IQueryInfos) => JexlRootContext<T>;
+    buildRecordContext: (record: IRecord, ctx: IQueryInfos) => JexlRecordContext;
+    buildTreeNodeContext: (treeNode: ITreeNode, ctx: IQueryInfos) => JexlTreeNodeContext;
+    buildValuesContext: (values: IValue[], ctx: IQueryInfos) => JexlValueContext[];
+}
+export default function ({ 'core.domain.value': valueDomain }: IDeps): IJexlDomain;
+export {};

package/apps/core/src/domain/jexl/jexlExtended.d.ts

@@ -0,0 +1,2 @@
+import jexl from 'jexl-extended';
+export default jexl;

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

@@ -0,0 +1,37 @@
+import { type IQueryInfos } from '../../_types/queryInfos';
+import { type IRecord } from '../../_types/record';
+import { type ITreeNode } from '../../_types/tree';
+import { type IStandardValue } from '../../_types/value';
+export declare enum JexlContextType {
+    ROOT = "root",
+    RECORD = "record",
+    TREE_NODE = "treeNode",
+    USER = "user"
+}
+export type JexlContext<T extends JexlContextType = JexlContextType> = {
+    /**
+     * This property is used internally to identify the type of context (root, record, tree node, user)
+     * and should not be used in Jexl expressions as it may cause conflicts with user-defined properties.
+     */
+    __jexlContextType: T;
+    /**
+     * This method is used internally to retrieve the IQueryInfos context for the current Jexl evaluation.
+     * It should not be used in Jexl expressions as it may cause conflicts with user-defined properties and is not intended for direct use in expressions.
+     */
+    __getJexlQueryCtx(): IQueryInfos;
+};
+/**
+ * The jexl context to be passed in jexl evaluation
+ * Still subject to change but the idea is to have a clear separation between root context (which can be defined by the user of the jexl domain)
+ * and record/tree node contexts which are built from values payload when using getValues transform or function in jexl expressions
+ */
+export type JexlRootContext<T = unknown> = T & JexlContext<JexlContextType.ROOT> & {
+    currentUser: JexlUserContext;
+};
+export type JexlRecordContext = IRecord & JexlContext<JexlContextType.RECORD>;
+export type JexlTreeNodeContext = ITreeNode & JexlContext<JexlContextType.TREE_NODE>;
+export type JexlUserContext = JexlContext<JexlContextType.USER> & {
+    record: JexlRecordContext;
+    lang?: string;
+};
+export type JexlValueContext = IStandardValue['payload'] | JexlRecordContext | JexlTreeNodeContext;