@aristid/leav-types 1.12.0-ca805ec3 → 1.12.0-cbe931d4

package/CLAUDE.md

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

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

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

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

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

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

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

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

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

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

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

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

@@ -91,6 +91,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

@@ -32,6 +32,7 @@ interface IDBPayloadDataMap {
     [EventAction.APP_SAVE]: IApplication;
     [EventAction.APP_DELETE]: IApplication;
     [EventAction.AUTOMATION_RULE_CREATE]: IAutomationRule;
+    [EventAction.AUTOMATION_RULE_UPDATE]: IAutomationRule;
     [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,17 +1,22 @@
 import { type IGraphqlAppModule } from '../graphql/graphqlApp';
 import { type IAutomationDomain } from '../../domain/automation/automationDomain';
+import { type IAutomationRule } from '../../_types/automation';
 import { type IPaginationParams, type ISortParams } from '../../_types/list';
+import { type IEventsManagerDomain } from '../../domain/eventsManager/eventsManagerDomain';
 export type ICoreImportApp = IGraphqlAppModule;
-interface IDeps {
+interface IAutomationAppDeps {
     'core.domain.automation': IAutomationDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
 }
 export interface IGetAutomationRulesArgs {
     filters?: ICoreEntityFilterOptions & {
-        id: string;
-        active: boolean;
+        active?: boolean;
+        synchronous?: boolean;
+        eventAction?: IAutomationRule['trigger']['eventAction'];
+        eventTopic?: IAutomationRule['trigger']['eventTopic'];
     };
     pagination?: IPaginationParams;
     sort?: ISortParams;
 }
-export default function ({ 'core.domain.automation': automationDomain }: IDeps): ICoreImportApp;
+export default function ({ 'core.domain.automation': automationDomain, 'core.domain.eventsManager': eventsManagerDomain, }: IAutomationAppDeps): ICoreImportApp;
 export {};

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

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

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { type IAutomationAction } from '../types';
+declare const conditionActionParamsSchema: z.ZodObject<{
+    result: z.ZodBoolean;
+}, z.core.$strip>;
+export type ConditionActionParams = z.infer<typeof conditionActionParamsSchema>;
+export default function (): IAutomationAction<ConditionActionParams>;
+export {};

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

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

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

@@ -0,0 +1,3 @@
+export { default as condition } from './conditionAction';
+export { default as error } from './errorAction';
+export { default as log } from './logAction';

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { type IAutomationAction } from '../types';
+declare const logActionParamsSchema: z.ZodObject<{
+    message: z.ZodString;
+    level: z.ZodOptional<z.ZodEnum<{
+        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,13 +1,18 @@
-import { type ICreateAutomationRule, 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';
 import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
+import { type IConfig } from '../../_types/config';
+import { type IPipelineExecutor } from './pipelineExecutor';
 export interface IGetAutomationRulesParams extends IGetCoreEntitiesParams {
     filters?: ICoreEntityFilterOptions & {
         active?: boolean;
+        synchronous?: boolean;
+        eventAction?: AutomationRuleEventAction;
+        eventTopic?: AutomationRulesEventTopic;
     };
 }
 export interface IAutomationDomain {
@@ -19,10 +24,20 @@ export interface IAutomationDomain {
         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, 'core.domain.eventsManager': eventsManagerDomain, 'core.infra.automation.rule': automationRuleRepo, }: IAutomationDomainDeps): IAutomationDomain;
+export default function ({ 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.automation.pipelineExecutor': pipelineExecutor, 'core.infra.automation.rule': automationRuleRepo, config, }: IAutomationDomainDeps): IAutomationDomain;

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

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

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

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

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

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

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

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

package/apps/core/src/domain/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/record/helpers/createRecord.d.ts

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

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

@@ -0,0 +1,27 @@
+import { type i18n } from 'i18next';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type IElementAncestorsHelper } from '../../tree/helpers/elementAncestors';
+import { type GetCoreEntityByIdFunc } from '../../helpers/getCoreEntityById';
+import { type IValidateHelper } from '../../helpers/validate';
+import { type FindRecordsHelper } from './findRecords';
+import { type ICachesService } from '../../../infra/cache/cacheService';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IRecord, type IRecordIdentity } from '../../../_types/record';
+import { type IUtils } from '../../../utils/utils';
+import type * as Config from '../../../_types/config';
+import { type GetRecordFieldValueHelper } from '../../value/helpers/getRecordFieldValue';
+export type GetRecordIdentityHelper = (record: IRecord, ctx: IQueryInfos) => Promise<IRecordIdentity>;
+interface IDeps {
+    config: Config.IConfig;
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.value.helpers.getRecordFieldValue': GetRecordFieldValueHelper;
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+    'core.domain.record.helpers.findRecords': FindRecordsHelper;
+    'core.infra.cache.cacheService': ICachesService;
+    'core.utils': IUtils;
+    translator: i18n;
+}
+export default function ({ config, 'core.domain.attribute': attributeDomain, 'core.domain.value.helpers.getRecordFieldValue': getRecordFieldValueHelper, 'core.domain.helpers.validate': validateHelper, 'core.domain.helpers.getCoreEntityById': getCoreEntityById, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper, 'core.domain.record.helpers.findRecords': findRecordsHelper, 'core.infra.cache.cacheService': cacheService, 'core.utils': utils, translator, }: IDeps): GetRecordIdentityHelper;
+export {};

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

@@ -2,3 +2,4 @@ export { default as createRecord } from './createRecord';
 export { default as deleteRecord } from './deleteRecord';
 export { default as sendRecordUpdateEvent } from './sendRecordUpdateEvent';
 export { default as findRecords } from './findRecords';
+export { default as getRecordIdentity } from './getRecordIdentity';

package/apps/core/src/domain/record/recordDomain.d.ts

@@ -1,11 +1,7 @@
 import { type IEventsManagerDomain } from '../eventsManager/eventsManagerDomain';
-import { type GetCoreEntityByIdFunc } from '../helpers/getCoreEntityById';
-import { type IValidateHelper } from '../helpers/validate';
 import { type IValueDomain } from '../value/valueDomain';
-import { type i18n } from 'i18next';
 import { type IRecordRepo } from '../../infra/record/recordRepo';
 import { type IUtils } from '../../utils/utils';
-import type * as Config from '../../_types/config';
 import { type IListWithCursor } from '../../_types/list';
 import { type ISaveValue, type IValue, type IValuesOptions } from '../../_types/value';
 import { type ICachesService } from '../../infra/cache/cacheService';
@@ -18,9 +14,9 @@ import { type IDuplicateRecordResult, type ICreateRecordResult, type ICreateReco
 import { type IFormRepo } from '../../infra/form/formRepo';
 import { type DeleteRecordHelper } from './helpers/deleteRecord';
 import { type CreateRecordHelper } from './helpers/createRecord';
-import { type IElementAncestorsHelper } from '../tree/helpers/elementAncestors';
 import { type ILogger } from '@leav/logger';
 import { type FindRecordsHelper } from './helpers/findRecords';
+import { type GetRecordIdentityHelper } from './helpers/getRecordIdentity';
 export declare const ATTRIBUTE_ACTIVE = "active";
 export interface IDuplicateRecordRules {
     attributesToDuplicate?: Array<{
@@ -118,23 +114,19 @@ export interface IRecordDomain {
     }): Promise<IDuplicateRecordResult[]>;
 }
 export interface IRecordDomainDeps {
-    config: Config.IConfig;
     'core.infra.record': IRecordRepo;
     'core.domain.attribute': IAttributeDomain;
     'core.domain.value': IValueDomain;
     'core.domain.permission.record': IRecordPermissionDomain;
-    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
-    'core.domain.helpers.validate': IValidateHelper;
     'core.domain.record.helpers.createRecord': CreateRecordHelper;
     'core.domain.record.helpers.deleteRecord': DeleteRecordHelper;
     'core.domain.record.helpers.findRecords': FindRecordsHelper;
+    'core.domain.record.helpers.getRecordIdentity': GetRecordIdentityHelper;
     'core.domain.record.helpers.sendRecordUpdateEvent': SendRecordUpdateEventHelper;
-    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.infra.form': IFormRepo;
     'core.domain.eventsManager': IEventsManagerDomain;
     'core.infra.cache.cacheService': ICachesService;
     'core.utils.logger': ILogger;
     'core.utils': IUtils;
-    translator: i18n;
 }
-export default function ({ config, 'core.infra.record': recordRepo, 'core.domain.attribute': attributeDomain, 'core.domain.value': valueDomain, 'core.domain.permission.record': recordPermissionDomain, 'core.domain.record.helpers.findRecords': findRecordsHelper, 'core.domain.helpers.getCoreEntityById': getCoreEntityById, 'core.domain.helpers.validate': validateHelper, 'core.domain.record.helpers.createRecord': createRecordHelper, 'core.domain.record.helpers.deleteRecord': deleteRecordHelper, 'core.domain.record.helpers.sendRecordUpdateEvent': sendRecordUpdateEvent, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper, 'core.infra.form': formRepo, 'core.domain.eventsManager': eventsManager, 'core.infra.cache.cacheService': cacheService, 'core.utils.logger': logger, 'core.utils': utils, translator, }: IRecordDomainDeps): IRecordDomain;
+export default function ({ 'core.infra.record': recordRepo, 'core.domain.attribute': attributeDomain, 'core.domain.value': valueDomain, 'core.domain.permission.record': recordPermissionDomain, 'core.domain.record.helpers.findRecords': findRecordsHelper, 'core.domain.record.helpers.getRecordIdentity': getRecordIdentityHelper, 'core.domain.record.helpers.createRecord': createRecordHelper, 'core.domain.record.helpers.deleteRecord': deleteRecordHelper, 'core.domain.record.helpers.sendRecordUpdateEvent': sendRecordUpdateEvent, 'core.infra.form': formRepo, 'core.domain.eventsManager': eventsManager, 'core.infra.cache.cacheService': cacheService, 'core.utils.logger': logger, 'core.utils': utils, }: IRecordDomainDeps): IRecordDomain;

package/apps/core/src/domain/value/helpers/formatValue.d.ts

@@ -0,0 +1,17 @@
+import { type ILogger } from '@leav/logger';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type IUtils } from '../../../utils/utils';
+import { type IAttribute } from '../../../_types/attribute';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IValue } from '../../../_types/value';
+export type FormatValueHelper = (params: {
+    attribute: IAttribute;
+    value: IValue;
+    ctx: IQueryInfos;
+}) => Promise<IValue>;
+export interface IFormatValueHelperDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.utils': IUtils;
+    'core.utils.logger': ILogger;
+}
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.utils': utils, 'core.utils.logger': logger, }: IFormatValueHelperDeps): FormatValueHelper;

package/apps/core/src/domain/value/helpers/getRecordFieldValue.d.ts

@@ -0,0 +1,27 @@
+import { type ILogger } from '@leav/logger';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type IRecordAttributePermissionDomain } from '../../permission/recordAttributePermissionDomain';
+import { type GetValuesHelper } from './getValues';
+import { type IRecordRepo } from '../../../infra/record/recordRepo';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IRecord } from '../../../_types/record';
+import { type IValue, type IValuesOptions } from '../../../_types/value';
+import { type FormatValueHelper } from './formatValue';
+import { type RunActionsListHelper } from './runActionsList';
+export type GetRecordFieldValueHelper = (params: {
+    library: string;
+    record: IRecord;
+    attributeId: string;
+    options?: IValuesOptions;
+    ctx: IQueryInfos;
+}) => Promise<IValue[]>;
+export interface IGetRecordFieldValueHelperDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.permission.recordAttribute': IRecordAttributePermissionDomain;
+    'core.domain.value.helpers.getValues': GetValuesHelper;
+    'core.domain.value.helpers.runActionsList': RunActionsListHelper;
+    'core.domain.value.helpers.formatValue': FormatValueHelper;
+    'core.infra.record': IRecordRepo;
+    'core.utils.logger': ILogger;
+}
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.domain.permission.recordAttribute': recordAttributePermissionDomain, 'core.domain.value.helpers.getValues': getValuesHelper, 'core.domain.value.helpers.runActionsList': runActionsListHelper, 'core.domain.value.helpers.formatValue': formatValueHelper, 'core.infra.record': recordRepo, 'core.utils.logger': logger, }: IGetRecordFieldValueHelperDeps): GetRecordFieldValueHelper;

package/apps/core/src/domain/value/helpers/getValues.d.ts

@@ -0,0 +1,26 @@
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type IValidateHelper } from '../../helpers/validate';
+import { type IGetDefaultElementHelper } from '../../tree/helpers/getDefaultElement';
+import { type IElementAncestorsHelper } from '../../tree/helpers/elementAncestors';
+import { type IVersionProfileDomain } from '../../versionProfile/versionProfileDomain';
+import { type IValueRepo } from '../../../infra/value/valueRepo';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IValue, type IValuesOptions } from '../../../_types/value';
+import { type RunActionsListHelper } from './runActionsList';
+export type GetValuesHelper = (params: {
+    library: string;
+    recordId: string;
+    attribute: string;
+    options?: IValuesOptions;
+    ctx: IQueryInfos;
+}) => Promise<IValue[]>;
+export interface IGetValuesHelperDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+    'core.domain.tree.helpers.getDefaultElement': IGetDefaultElementHelper;
+    'core.domain.versionProfile': IVersionProfileDomain;
+    'core.domain.value.helpers.runActionsList': RunActionsListHelper;
+    'core.infra.value': IValueRepo;
+}
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.domain.helpers.validate': validate, 'core.domain.tree.helpers.elementAncestors': elementAncestors, 'core.domain.tree.helpers.getDefaultElement': getDefaultElementHelper, 'core.domain.versionProfile': versionProfileDomain, 'core.domain.value.helpers.runActionsList': runActionsListHelper, 'core.infra.value': valueRepo, }: IGetValuesHelperDeps): GetValuesHelper;

package/apps/core/src/domain/value/helpers/index.d.ts

@@ -1 +1,8 @@
 export { default as formatLogValue } from './formatLogValue';
+export { default as formatValue } from './formatValue';
+export type { FormatValueHelper } from './formatValue';
+export { default as getRecordFieldValue } from './getRecordFieldValue';
+export { default as getValues } from './getValues';
+export type { GetValuesHelper } from './getValues';
+export { default as runActionsList } from './runActionsList';
+export type { RunActionsListHelper } from './runActionsList';

package/apps/core/src/domain/value/helpers/manageEventMetadata.d.ts

@@ -0,0 +1,4 @@
+export declare const setMetadataRecordLabel: (recordLabel: string) => {
+    recordLabel?: string;
+};
+export declare const getMetadataRecordLabel: (metadata: Record<string, any> | undefined) => any;

package/apps/core/src/domain/value/helpers/runActionsList.d.ts

@@ -0,0 +1,10 @@
+import { type IActionsListDomain } from '../../actionsList/actionsListDomain';
+import { type IUtils } from '../../../utils/utils';
+import { type IValue } from '../../../_types/value';
+import { type IRunActionListParams } from '../_types';
+export type RunActionsListHelper = (params: IRunActionListParams) => Promise<IValue[]>;
+export interface IRunActionsListHelperDeps {
+    'core.domain.actionsList': IActionsListDomain;
+    'core.utils': IUtils;
+}
+export default function ({ 'core.domain.actionsList': actionsListDomain, 'core.utils': utils, }: IRunActionsListHelperDeps): RunActionsListHelper;