@aristid/leav-types 1.5.0 → 1.5.1-1929c505

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

@@ -105,8 +105,22 @@ export declare namespace lang {
     export { _default as default };
 }
 export declare namespace permissions {
-    let _default_1: boolean;
-    export { _default_1 as default };
+    export namespace everybody {
+        let _default_1: boolean;
+        export { _default_1 as default };
+        export namespace admin_1 {
+            let _default_2: boolean;
+            export { _default_2 as default };
+        }
+        export { admin_1 as admin };
+        export namespace application {
+            let admin_application: boolean;
+        }
+    }
+    export namespace adminGroup {
+        let _default_3: boolean;
+        export { _default_3 as default };
+    }
     let enableCache_1: boolean;
     export { enableCache_1 as enableCache };
 }

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

@@ -5,11 +5,22 @@ import FormData from 'form-data';
 import { type ActionsListConfig } from '_types/actionsList';
 import { type ITreeElement } from '_types/tree';
 import { AttributeFormats, type AttributeTypes, type IAttributeVersionsConf, type IEmbeddedAttribute } from '../../../_types/attribute';
+export interface IGlobalThis {
+    guestUser: IE2EUserParams;
+    nonAdminUser: IE2EUserParams;
+    nonAdminGroupId: string;
+}
 interface IE2EUser {
     getAuthToken: () => Promise<string>;
 }
+interface IE2EUserParams {
+    userId: string;
+    groupsId: string[];
+}
 export declare const e2eAdminUser: () => IE2EUser;
-export declare const e2eGuestUser: () => Promise<IE2EUser>;
+export declare const e2eGuestUser: () => IE2EUser;
+export declare const e2eNonAdminUser: () => IE2EUser;
+export declare const e2eNonAdminGroupId: () => string;
 export declare function getGraphQLUrl(): Promise<string>;
 export declare class E2EGraphQLError extends Error {
     readonly response: AxiosResponse;
@@ -42,8 +53,6 @@ export declare function gqlSaveAttribute(params: {
 }): Promise<any>;
 export declare function gqlSaveTree(id: string, label: string, libraries: string[]): Promise<any>;
 export declare function gqlCreateRecord(library: string): Promise<string>;
-export declare function gqlGetAdminsGroupNodeId(): Promise<string>;
-export declare function gqlAddUserToGroup(groupNodeId: string): Promise<void>;
 /**
  * Add an element to the tree
  *

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

@@ -17,5 +17,13 @@ interface IMailpitMsgFull extends IMailpitMsgLight {
     HTML: string;
     Text: string;
 }
+interface IMailpitSearchResult {
+    messages: IMailpitMsgLight[];
+    total: number;
+    unread: number;
+}
 export declare function waitMailpitMessage(acceptMessage: (msg: IMailpitMsgLight) => boolean): Promise<IMailpitMsgFull>;
+export declare function deleteMailpitMessagesBySearch(search: string): Promise<void>;
+export declare function searchMailpitMessages(search: string): Promise<IMailpitSearchResult>;
+export declare function waitForMailpitSearchMessage(search: string, timeoutMs?: number, intervalMs?: number): Promise<IMailpitMsgLight[]>;
 export {};

package/apps/core/src/__tests__/e2e/api/userData/maskUserPassword.test.d.ts

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

package/apps/core/src/__tests__/e2e/api/values/countValuesOccurrences.test.d.ts

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

package/apps/core/src/__tests__/e2e/api/values/saveValueBulk.test.d.ts

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

package/apps/core/src/_constants/values.d.ts

@@ -0,0 +1 @@
+export declare const MASKED_VALUE = "\u25CF\u25CF\u25CF\u25CF\u25CF\u25CF\u25CF";

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

@@ -1,5 +1,6 @@
 import { type Options } from 'amqplib';
 import { type IKeyValue } from './shared';
+import { type PermissionsActions, type AdminPermissionsActions, type ApplicationPermissionsActions, type AttributePermissionsActions, type LibraryPermissionsActions, type PermissionTypes, type RecordAttributePermissionsActions, type RecordPermissionsActions, type TreeNodePermissionsActions, type TreePermissionsActions } from './permissions';
 export interface IConfig {
     coreMode: CoreMode;
     server: IServer;
@@ -134,8 +135,26 @@ export interface ILang {
     available: string[];
     default: string;
 }
-export interface IPermissions {
+type IPermissionsByActions<PermissionActions extends PermissionsActions> = {
+    [P in PermissionActions]?: boolean;
+} & {
+    default?: boolean;
+};
+interface IPermissionsByTypesAndActions {
     default: boolean;
+    [PermissionTypes.ADMIN]?: IPermissionsByActions<AdminPermissionsActions>;
+    [PermissionTypes.APPLICATION]?: IPermissionsByActions<ApplicationPermissionsActions>;
+    [PermissionTypes.ATTRIBUTE]?: IPermissionsByActions<AttributePermissionsActions>;
+    [PermissionTypes.LIBRARY]?: IPermissionsByActions<LibraryPermissionsActions>;
+    [PermissionTypes.RECORD]?: IPermissionsByActions<RecordPermissionsActions>;
+    [PermissionTypes.RECORD_ATTRIBUTE]?: IPermissionsByActions<RecordAttributePermissionsActions>;
+    [PermissionTypes.TREE]?: IPermissionsByActions<TreePermissionsActions>;
+    [PermissionTypes.TREE_NODE]?: IPermissionsByActions<TreeNodePermissionsActions>;
+    [PermissionTypes.TREE_LIBRARY]?: IPermissionsByActions<TreeNodePermissionsActions>;
+}
+export interface IPermissions {
+    everybody: IPermissionsByTypesAndActions;
+    adminGroup: IPermissionsByTypesAndActions;
     enableCache: boolean;
 }
 export interface IAmqp {
@@ -280,3 +299,4 @@ export interface IMatomo {
 export interface ILogsCollector {
     queue: string;
 }
+export {};

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

@@ -77,6 +77,9 @@ export declare enum Errors {
     TOO_MUCH_LIBRARIES_ON_FILES_TREE = "TOO_MUCH_LIBRARIES_ON_FILES_TREE",
     UNBINDED_ATTRIBUTES = "UNBINDED_ATTRIBUTES",
     UNIQUE_VALUE_NOT_ALLOWED = "UNIQUE_VALUE_NOT_ALLOWED",
+    UNSUPPORTED_ATTRIBUTE_TYPE = "UNSUPPORTED_ATTRIBUTE_TYPE",
+    UNSUPPORTED_ATTRIBUTE_MULTI_VALUE = "UNSUPPORTED_ATTRIBUTE_MULTI_VALUE",
+    UNSUPPORTED_ATTRIBUTE_WITH_ACTIONS = "UNSUPPORTED_ATTRIBUTE_WITH_ACTIONS",
     UNKNOWN_API_KEY = "UNKNOWN_API_KEY",
     UNKNOWN_APPLICATION = "UNKNOWN_APPLICATION",
     UNKNOWN_ATTRIBUTE = "UNKNOWN_ATTRIBUTE",

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

@@ -8,15 +8,16 @@ import { type IRecord } from './record';
 import { type IValue } from './value';
 import { type IVersionProfile } from './versionProfile';
 import { type IPermission } from './permissions';
-import { type ITree } from './tree';
+import { type ITreeDbEvent, type ITree } from './tree';
+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
  * without having to redeclare them. For now before and after are any in @leav/utils
  */
 export interface IDbPayloadInternal<DBPayloadAction extends EventAction> extends IDbPayload {
     action: DBPayloadAction;
-    before?: IDBPayloadData<DBPayloadAction>;
-    after?: IDBPayloadData<DBPayloadAction>;
+    before?: OnlyObject<IDBPayloadData<DBPayloadAction>>;
+    after?: OnlyObject<IDBPayloadData<DBPayloadAction>>;
 }
 interface IDBPayloadDataMap {
     [EventAction.VALUE_SAVE]: IValue;
@@ -34,9 +35,9 @@ interface IDBPayloadDataMap {
     [EventAction.LIBRARY_DELETE]: ILibraryDbEvent;
     [EventAction.VERSION_PROFILE_SAVE]: IVersionProfile;
     [EventAction.VERSION_PROFILE_DELETE]: IVersionProfile;
-    [EventAction.TREE_ADD_ELEMENT]: string;
-    [EventAction.TREE_DELETE_ELEMENT]: string;
-    [EventAction.TREE_MOVE_ELEMENT]: string;
+    [EventAction.TREE_ADD_ELEMENT]: ITreeDbEvent;
+    [EventAction.TREE_DELETE_ELEMENT]: ITreeDbEvent;
+    [EventAction.TREE_MOVE_ELEMENT]: ITreeDbEvent;
     [EventAction.TREE_SAVE]: ITree;
     [EventAction.TREE_DELETE]: ITree;
     [EventAction.PERMISSION_SAVE]: IPermission;

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

@@ -11,7 +11,7 @@ export interface INotification {
     content: INotificationContent;
 }
 export interface INotificationContent {
-    level: 'info' | 'warning';
+    level: 'success' | 'info' | 'warning' | 'error';
     title: string;
     message: string;
     relatedEntities?: Array<{

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

@@ -63,7 +63,8 @@ export declare enum TaskType {
     EXPORT = "EXPORT",
     IMPORT_CONFIG = "IMPORT_CONFIG",
     IMPORT_DATA = "IMPORT_DATA",
-    INDEXATION = "INDEXATION"
+    INDEXATION = "INDEXATION",
+    SAVE_VALUE_BULK = "SAVE_VALUE_BULK"
 }
 export interface ITaskRole {
     type: TaskType;

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

@@ -62,3 +62,8 @@ export interface ITreeEvent {
     };
     order: number;
 }
+export interface ITreeDbEvent {
+    parentNode: {
+        id: string;
+    };
+}

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

@@ -49,7 +49,7 @@ export interface IGenericValue extends ICommonGenericSaveValue {
     isInherited?: boolean;
     isCalculated?: boolean;
 }
-export interface IStandardValue extends IGenericValue {
+export interface IStandardBaseValue {
     /**
      * Computed value after get actions on attribute are done
      * TODO remove that any when possible
@@ -62,14 +62,14 @@ export interface IStandardValue extends IGenericValue {
      */
     raw_payload?: any;
 }
-export interface ILinkValue extends IGenericValue {
+export interface ILinkBaseValue {
     /**
      * Linked record
      * TODO remove optional when possible
      */
     payload?: IRecord;
 }
-export interface ITreeValue extends IGenericValue {
+export interface ITreeBaseValue {
     /**
      * Linked tree node
      * TODO remove optional when possible
@@ -77,6 +77,13 @@ export interface ITreeValue extends IGenericValue {
     payload?: ITreeNode;
     treeId: string;
 }
+export interface IStandardValue extends IGenericValue, IStandardBaseValue {
+}
+export interface ILinkValue extends IGenericValue, ILinkBaseValue {
+}
+export interface ITreeValue extends IGenericValue, ITreeBaseValue {
+}
+export type IBaseValue = IStandardBaseValue | ILinkBaseValue | ITreeBaseValue;
 export type IValue = IStandardValue | ILinkValue | ITreeValue;
 type IGenericSaveValue = ICommonGenericSaveValue;
 export interface ISaveStandardValue extends IGenericSaveValue {
@@ -106,6 +113,7 @@ export interface IValuesOptions {
     version?: IValueVersion;
     forceArray?: boolean;
     forceGetAllValues?: boolean;
+    skipActions?: boolean;
     [optionName: string]: any;
 }
 export interface IFindValueTree {
@@ -136,4 +144,19 @@ export interface ISaveValueByAttributeType {
     [AttributeTypes.ADVANCED_LINK]: ISaveLinkValue;
     [AttributeTypes.TREE]: ISaveTreeValue;
 }
+export interface IBaseValueByAttributeType {
+    [AttributeTypes.SIMPLE]: IStandardBaseValue;
+    [AttributeTypes.SIMPLE_LINK]: ILinkBaseValue;
+    [AttributeTypes.ADVANCED]: IStandardBaseValue;
+    [AttributeTypes.ADVANCED_LINK]: ILinkBaseValue;
+    [AttributeTypes.TREE]: ITreeBaseValue;
+}
+export type IValuesOccurrences<SimpleValueType extends IBaseValue = IBaseValue> = Array<{
+    value: SimpleValueType;
+    count: number;
+}>;
+export interface IValuesOccurrencesResult<BaseValueType extends IBaseValue = IBaseValue> {
+    occurrences: IValuesOccurrences<BaseValueType>;
+    noValueCount: number;
+}
 export {};

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

@@ -4,13 +4,15 @@ import { type IRecordDomain } from 'domain/record/recordDomain';
 import { type IValueDomain } from 'domain/value/valueDomain';
 import { type IUtils } from 'utils/utils';
 import { type IGraphqlAppModule } from 'app/graphql/graphqlApp';
+import { type ISaveValueBulkTask } from '../../domain/value/tasks/saveValueBulk';
 export type ICoreValueApp = IGraphqlAppModule;
 interface IDeps {
     'core.domain.value': IValueDomain;
     'core.domain.attribute': IAttributeDomain;
     'core.domain.record': IRecordDomain;
+    'core.domain.value.tasks.saveValueBulk': ISaveValueBulkTask;
     'core.app.helpers.convertVersionFromGqlFormat': ConvertVersionFromGqlFormatFunc;
     'core.utils': IUtils;
 }
-export default function ({ 'core.domain.value': valueDomain, 'core.domain.record': recordDomain, 'core.domain.attribute': attributeDomain, 'core.app.helpers.convertVersionFromGqlFormat': convertVersionFromGqlFormat, 'core.utils': utils, }: IDeps): ICoreValueApp;
+export default function ({ 'core.domain.value': valueDomain, 'core.domain.record': recordDomain, 'core.domain.value.tasks.saveValueBulk': saveValueBulkTask, 'core.domain.attribute': attributeDomain, 'core.app.helpers.convertVersionFromGqlFormat': convertVersionFromGqlFormat, 'core.utils': utils, }: IDeps): ICoreValueApp;
 export {};

package/apps/core/src/domain/filesManager/filesManagerDomain.d.ts

@@ -8,7 +8,7 @@ import { type ILibraryPermissionDomain } from 'domain/permission/libraryPermissi
 import { type SendRecordUpdateEventHelper } from 'domain/record/helpers/sendRecordUpdateEvent';
 import { type ITreeDomain } from 'domain/tree/treeDomain';
 import { type IValueDomain } from 'domain/value/valueDomain';
-import { type FileUpload } from 'graphql-upload';
+import { type FileUpload } from 'graphql-upload/Upload.mjs';
 import { type i18n } from 'i18next';
 import { type IRecordRepo } from 'infra/record/recordRepo';
 import { type IUtils } from 'utils/utils';

package/apps/core/src/domain/helpers/storeUploadFile.d.ts

@@ -1,4 +1,4 @@
-import { type FileUpload } from 'graphql-upload';
+import { type FileUpload } from 'graphql-upload/Upload.mjs';
 import { type Progress } from 'progress-stream';
 export type StoreUploadFileFunc = (fileData: FileUpload, path: string, onProgress?: (progress: Progress) => Promise<void>, size?: number) => Promise<void>;
 export default function (): (fileData: FileUpload, path: string, onProgress?: (progress: Progress) => void, size?: number) => Promise<void>;

package/apps/core/src/domain/library/helpers/checkSavePermission.d.ts

@@ -1,7 +1,7 @@
 import { type IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
 import { type IQueryInfos } from '_types/queryInfos';
 import { AdminPermissionsActions } from '../../../_types/permissions';
-declare const _default: (existingLib: boolean, userId: string, deps: {
+declare const _default: (existingLib: boolean, deps: {
     adminPermissionDomain: IAdminPermissionDomain;
 }, ctx: IQueryInfos) => Promise<{
     canSave: boolean;

package/apps/core/src/domain/permission/_types.d.ts

@@ -1,6 +1,5 @@
 import { type AdminPermissionsActions, type ApplicationPermissionsActions, type AttributePermissionsActions, type IPermissionsTreeTarget, type ITreePermissionsConf, type LibraryPermissionsActions, type PermissionsActions, type PermissionTypes, type RecordAttributePermissionsActions, type RecordPermissionsActions, type TreeNodePermissionsActions, type TreePermissionsActions } from '_types/permissions';
 import { type IQueryInfos } from '_types/queryInfos';
-import { type TreePath } from '_types/tree';
 import { type IGetDefaultPermissionParams } from './helpers/defaultPermission';
 export declare const PERMISSIONS_CACHE_HEADER = "permissions";
 export declare const PERMISSIONS_NULL_PLACEHOLDER = "__null__";
@@ -31,7 +30,6 @@ export type PermByActionsRes = {
 } | null;
 export interface IGetAdminPermissionParams {
     action: AdminPermissionsActions;
-    userId: string;
     ctx: IQueryInfos;
 }
 export interface IGetInheritedAdminPermissionParams {
@@ -42,13 +40,11 @@ export interface IGetInheritedAdminPermissionParams {
 export interface IGetLibraryPermissionParams {
     action: LibraryPermissionsActions;
     libraryId: string;
-    userId: string;
     ctx: IQueryInfos;
 }
 export interface IGetTreePermissionParams {
     action: TreePermissionsActions;
     treeId: string;
-    userId: string;
     ctx: IQueryInfos;
 }
 export type GetDefaultTreeLibraryPermission = (params: IGetDefaultPermissionParams) => boolean | null;
@@ -56,27 +52,20 @@ export interface IGetTreeLibraryPermissionParams {
     action: TreeNodePermissionsActions;
     treeId: string;
     libraryId: string;
-    userId: string;
     getDefaultTreeLibraryPermission?: GetDefaultTreeLibraryPermission;
     ctx: IQueryInfos;
 }
 export interface IGetApplicationPermissionParams {
     action: ApplicationPermissionsActions;
     applicationId: string;
-    userId: string;
     ctx: IQueryInfos;
 }
 export interface IGetDefaultGlobalPermissionParams extends IGetDefaultPermissionParams {
-    type?: PermissionTypes;
     applyTo?: string;
-    userId?: string;
-    userGroups?: TreePath[];
-    action?: PermissionsActions;
 }
 export type GetDefaultGlobalPermission = (params: IGetDefaultGlobalPermissionParams) => Promise<boolean> | boolean;
 export interface IGetTreeNodePermissionParams {
     action: TreeNodePermissionsActions;
-    userId: string;
     nodeId: string;
     treeId: string;
     ctx: IQueryInfos;
@@ -137,7 +126,6 @@ export interface IGetInheritedPermissionsParams {
 export interface IIsAllowedParams {
     type: PermissionTypes;
     action: PermissionsActions;
-    userId: string;
     applyTo?: string;
     target?: IPermissionTarget;
     ctx: IQueryInfos;
@@ -157,7 +145,6 @@ export interface IGetRecordAttributeHeritedPermissionsParams {
 export interface IGetTreeBasedPermissionParams {
     type: PermissionTypes;
     action: PermissionsActions;
-    userId: string;
     applyTo: string;
     treeValues: {
         [treeAttributeId: string]: string[];
@@ -175,7 +162,6 @@ export interface IGetInheritedTreeBasedPermissionParams {
 }
 export interface IGetRecordPermissionParams {
     action: RecordPermissionsActions;
-    userId: string;
     library: string;
     recordId: string;
     ctx: IQueryInfos;
@@ -190,7 +176,6 @@ export interface IGetInheritedRecordPermissionParams {
 }
 export interface IEstimateTreeValueRecordPermissionParams {
     action: RecordPermissionsActions;
-    userId: string;
     libraryId: string;
     attributeId: string;
     nodeId: string;

package/apps/core/src/domain/permission/adminPermissionDomain.d.ts

@@ -1,7 +1,7 @@
 import { type IGlobalPermissionHelper } from './helpers/globalPermission';
 import { type IGetAdminPermissionParams, type IGetInheritedAdminPermissionParams } from './_types';
 export interface IAdminPermissionDomain {
-    getAdminPermission({ action, userId, ctx }: IGetAdminPermissionParams): Promise<boolean>;
+    getAdminPermission({ action, ctx }: IGetAdminPermissionParams): Promise<boolean>;
     getInheritedAdminPermission({ action, userGroupId, ctx }: IGetInheritedAdminPermissionParams): Promise<boolean>;
 }
 interface IDeps {

package/apps/core/src/domain/permission/helpers/defaultPermission.d.ts

@@ -1,14 +1,20 @@
 import { type IConfig } from '_types/config';
+import { PermissionTypes, type PermissionsActions } from '../../../_types/permissions';
 import { type IQueryInfos } from '_types/queryInfos';
+import { type TreePath } from '_types/tree';
 interface IDeps {
     config: IConfig;
 }
 export interface IGetDefaultPermissionParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userGroups: TreePath[];
     ctx: IQueryInfos;
 }
-export type GetDefaultPermission = ({ ctx }: IGetDefaultPermissionParams) => boolean;
+export type GetDefaultPermission = ({ ctx, type, action, userGroups }: IGetDefaultPermissionParams) => boolean;
 export interface IDefaultPermissionHelper {
     getDefaultPermission: GetDefaultPermission;
+    getAdminDefaultPermissionOrNull: GetDefaultPermission;
 }
 export default function ({ config }: IDeps): IDefaultPermissionHelper;
 export {};

package/apps/core/src/domain/permission/permissionDomain.d.ts

@@ -15,6 +15,7 @@ import { type ITreeLibraryPermissionDomain } from './treeLibraryPermissionDomain
 import { type ITreeNodePermissionDomain } from './treeNodePermissionDomain';
 import { type ITreePermissionDomain } from './treePermissionDomain';
 import { type IGetActionsByTypeParams, type IGetInheritedPermissionsParams, type IGetPermissionsByActionsParams, type IIsAllowedParams, type PermByActionsRes } from './_types';
+import { type IDefaultPermissionHelper } from './helpers/defaultPermission';
 export interface IPermissionDomain {
     savePermission(permData: IPermission, ctx: IQueryInfos): Promise<IPermission>;
     getPermissionsByActions({ type, applyTo, actions, usersGroupNodeId, permissionTreeTarget, ctx, }: IGetPermissionsByActionsParams): Promise<PermByActionsRes>;
@@ -22,7 +23,7 @@ export interface IPermissionDomain {
      * Retrieve herited permission: ignore permission defined on given element, force retrieval of herited permission
      */
     getInheritedPermissions({ type, applyTo, action, userGroupId, permissionTreeTarget, ctx, }: IGetInheritedPermissionsParams): Promise<boolean>;
-    isAllowed({ type, action, userId, applyTo, target, ctx }: IIsAllowedParams): Promise<boolean>;
+    isAllowed({ type, action, applyTo, target, ctx }: IIsAllowedParams): Promise<boolean>;
     getActionsByType(params: IGetActionsByTypeParams): ILabeledPermissionsAction[];
     registerActions(type: PermissionTypes, actions: string[], applyOn?: string[]): void;
     isAdminOrSystemUser(ctx: IQueryInfos): boolean;
@@ -37,6 +38,7 @@ export interface IPermissionDomainDeps {
     'core.domain.permission.treeNode': ITreeNodePermissionDomain;
     'core.domain.permission.treeLibrary': ITreeLibraryPermissionDomain;
     'core.domain.permission.application': IApplicationPermissionDomain;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
     'core.domain.eventsManager': IEventsManagerDomain;
     'core.infra.permission': IPermissionRepo;
     'core.infra.cache.cacheService': ICachesService;

package/apps/core/src/domain/permission/recordAttributePermissionDomain.d.ts

@@ -1,23 +1,21 @@
 import { type IValueRepo } from 'infra/value/valueRepo';
 import { type IQueryInfos } from '_types/queryInfos';
-import { type RecordAttributePermissionsActions } from '../../_types/permissions';
+import { RecordAttributePermissionsActions } from '../../_types/permissions';
 import { type IAttributeDomain } from '../attribute/attributeDomain';
 import { type IAttributePermissionDomain } from './attributePermissionDomain';
-import { type IDefaultPermissionHelper } from './helpers/defaultPermission';
 import { type IPermissionByUserGroupsHelper } from './helpers/permissionByUserGroups';
 import { type ITreeBasedPermissionHelper } from './helpers/treeBasedPermissions';
 import { type IGetRecordAttributeHeritedPermissionsParams as IGetRecordAttributeInheritedPermissionsParams } from './_types';
 import { type IRecordRepo } from '../../infra/record/recordRepo';
 import { type IRecordInCreationBypassHelper } from './helpers/recordInCreationBypass';
 export interface IRecordAttributePermissionDomain {
-    getRecordAttributePermission(action: RecordAttributePermissionsActions, userGroupId: string, attributeId: string, recordLibrary: string, recordId: string, ctx: IQueryInfos): Promise<boolean>;
+    getRecordAttributePermission(action: RecordAttributePermissionsActions, attributeId: string, recordLibrary: string, recordId: string, ctx: IQueryInfos): Promise<boolean>;
     getInheritedRecordAttributePermission(params: IGetRecordAttributeInheritedPermissionsParams, ctx: IQueryInfos): Promise<boolean>;
 }
 export interface IRecordAttributePermissionDomainDeps {
     'core.domain.permission.attribute': IAttributePermissionDomain;
     'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
     'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
-    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
     'core.domain.permission.helpers.recordInCreationBypass': IRecordInCreationBypassHelper;
     'core.domain.attribute': IAttributeDomain;
     'core.infra.value': IValueRepo;

package/apps/core/src/domain/permission/recordPermissionDomain.d.ts

@@ -1,7 +1,6 @@
 import { type GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
 import { type IValueRepo } from 'infra/value/valueRepo';
 import { type IAttributeDomain } from '../attribute/attributeDomain';
-import { type IDefaultPermissionHelper } from './helpers/defaultPermission';
 import { type IPermissionByUserGroupsHelper } from './helpers/permissionByUserGroups';
 import { type ITreeBasedPermissionHelper } from './helpers/treeBasedPermissions';
 import { type ILibraryPermissionDomain } from './libraryPermissionDomain';
@@ -18,7 +17,6 @@ export interface IRecordPermissionDomainDeps {
     'core.domain.permission.library': ILibraryPermissionDomain;
     'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
     'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
-    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
     'core.domain.permission.helpers.recordInCreationBypass': IRecordInCreationBypassHelper;
     'core.domain.attribute': IAttributeDomain;
     'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;

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

@@ -0,0 +1,38 @@
+import { type ILibraryPermissionDomain } from 'domain/permission/libraryPermissionDomain';
+import { type IRecordRepo } from 'infra/record/recordRepo';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IRecord } from '../../../_types/record';
+import { type IFindRecordParams } from '../_types';
+import { type IPermissionRepo } from '../../../infra/permission/permissionRepo';
+import { type IListWithCursor } from '../../../_types/list';
+import { type IValidateHelper } from '../../helpers/validate';
+import { type IUtils } from '../../../utils/utils';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type ILibraryRepo } from '../../../infra/library/libraryRepo';
+import { type ITreeRepo } from '../../../infra/tree/treeRepo';
+import { type GetCoreEntityByIdFunc } from '../../helpers/getCoreEntityById';
+import { type IElementAncestorsHelper } from '../../tree/helpers/elementAncestors';
+import { type IDefaultPermissionHelper } from '../../permission/helpers/defaultPermission';
+/**
+ * Search records
+ * Filters to apply on records selection
+ * Fields to retrieve on each records
+ */
+export type FindRecordsHelper = ({ params, ctx, }: {
+    params: IFindRecordParams;
+    ctx: IQueryInfos;
+}) => Promise<IListWithCursor<IRecord>>;
+export interface IFindRecordsHelperDeps {
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.permission.library': ILibraryPermissionDomain;
+    'core.domain.attribute': IAttributeDomain;
+    'core.infra.record': IRecordRepo;
+    'core.infra.library': ILibraryRepo;
+    'core.infra.tree': ITreeRepo;
+    'core.utils': IUtils;
+    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.infra.permission': IPermissionRepo;
+}
+export default function ({ 'core.domain.helpers.validate': validateHelper, 'core.domain.attribute': attributeDomain, 'core.domain.permission.helpers.defaultPermission': defaultPermHelper, 'core.infra.library': libraryRepo, 'core.domain.permission.library': libraryPermissionDomain, 'core.infra.record': recordRepo, 'core.domain.helpers.getCoreEntityById': getCoreEntityById, 'core.infra.tree': treeRepo, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper, 'core.infra.permission': permissionRepo, 'core.utils': utils, }: IFindRecordsHelperDeps): FindRecordsHelper;

package/apps/core/src/domain/record/helpers/findRecords.spec.d.ts

@@ -0,0 +1 @@
+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 getAccessPermissionFilters } from './getAccessPermissionFilters';
+export { default as findRecords } from './findRecords';

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

@@ -1,12 +1,9 @@
 import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
 import { type GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
 import { type IValidateHelper } from 'domain/helpers/validate';
-import { type ILibraryPermissionDomain } from 'domain/permission/libraryPermissionDomain';
 import { type IValueDomain } from 'domain/value/valueDomain';
 import { type i18n } from 'i18next';
-import { type ILibraryRepo } from 'infra/library/libraryRepo';
 import { type IRecordRepo } from 'infra/record/recordRepo';
-import { type ITreeRepo } from 'infra/tree/treeRepo';
 import { type IUtils } from 'utils/utils';
 import type * as Config from '_types/config';
 import { type IListWithCursor } from '_types/list';
@@ -19,13 +16,11 @@ import { type IRecordPermissionDomain } from '../permission/recordPermissionDoma
 import { type SendRecordUpdateEventHelper } from './helpers/sendRecordUpdateEvent';
 import { type ICreateRecordResult, type IFindRecordParams } from './_types';
 import { type IFormRepo } from 'infra/form/formRepo';
-import { type IRecordAttributePermissionDomain } from '../permission/recordAttributePermissionDomain';
-import { type IPermissionRepo } from '../../infra/permission/permissionRepo';
-import { type IDefaultPermissionHelper } from 'domain/permission/helpers/defaultPermission';
 import { type DeleteRecordHelper } from './helpers/deleteRecord';
 import { type CreateRecordHelper } from './helpers/createRecord';
 import { type IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
 import { type ILogger } from '@leav/logger';
+import { type FindRecordsHelper } from './helpers/findRecords';
 export declare const ATTRIBUTE_ACTIVE = "active";
 export interface IRecordDomain {
     /**
@@ -73,16 +68,7 @@ export interface IRecordDomain {
         ctx: IQueryInfos;
     }): Promise<IListWithCursor<IRecord>>;
     /**
-     * Get the value of targeted attribute with actions applied on it including metadata.
-     *
-     * Avoid requesting DB if attribute already found in `record` param.
-     *
-     * @param {Object} params
-     * @param params.library
-     * @param params.record Could be emulated with only `{ id: <real_id> }`
-     * @param params.attributeId
-     * @param params.options
-     * @param params.ctx
+     * @deprecated use valueDomain.getRecordFieldValue instead
      */
     getRecordFieldValue({ library, record, attributeId, options, ctx, }: {
         library: string;
@@ -122,23 +108,18 @@ export interface IRecordDomainDeps {
     'core.domain.attribute': IAttributeDomain;
     'core.domain.value': IValueDomain;
     'core.domain.permission.record': IRecordPermissionDomain;
-    'core.domain.permission.library': ILibraryPermissionDomain;
-    'core.domain.permission.recordAttribute': IRecordAttributePermissionDomain;
-    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
     '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.sendRecordUpdateEvent': SendRecordUpdateEventHelper;
-    'core.infra.library': ILibraryRepo;
-    'core.infra.tree': ITreeRepo;
     'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.infra.form': IFormRepo;
-    'core.infra.permission': IPermissionRepo;
     '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.permission.library': libraryPermissionDomain, 'core.domain.permission.recordAttribute': recordAttributePermissionDomain, 'core.domain.permission.helpers.defaultPermission': defaultPermHelper, '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.infra.library': libraryRepo, 'core.infra.tree': treeRepo, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper, 'core.infra.form': formRepo, 'core.infra.permission': permissionRepo, 'core.domain.eventsManager': eventsManager, 'core.infra.cache.cacheService': cacheService, 'core.utils.logger': logger, 'core.utils': utils, translator, }: IRecordDomainDeps): IRecordDomain;
+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;

package/apps/core/src/domain/user/userDomain.d.ts

@@ -20,6 +20,7 @@ export interface IUserDomain {
     saveUserData(params: ISaveUserDataParams): Promise<IUserData>;
     getUserData(keys: string[], global: boolean, ctx: IQueryInfos): Promise<IUserData>;
     sendResetPasswordEmail(email: string, token: string, login: string, browser: string, os: string, lang: 'fr' | 'en', ctx: IQueryInfos): Promise<void>;
+    verifyPassword(userId: string, password: string, ctx: IQueryInfos): Promise<boolean>;
 }
 export interface IUserDomainDeps {
     config: Config.IConfig;

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

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

package/apps/core/src/domain/value/tasks/saveValueBulk.d.ts

@@ -0,0 +1,36 @@
+import { type IValidateHelper } from 'domain/helpers/validate';
+import { type IValueDomain } from 'domain/value/valueDomain';
+import { type i18n } from 'i18next';
+import type * as Config from '_types/config';
+import { type IQueryInfos } from '../../../_types/queryInfos';
+import { type IRecordFilterLight } from '../../../_types/record';
+import { type ITreeNode } from '../../../_types/tree';
+import { type IAttributeDomain } from '../../attribute/attributeDomain';
+import { type FindRecordsHelper } from '../../record/helpers/findRecords';
+import { type ITaskFuncParams } from '../../../_types/tasksManager';
+import { type ITasksManagerDomain } from '../../tasksManager/tasksManagerDomain';
+import { type INotificationDomain } from '../../notification/notificationDomain';
+export interface ISaveValueBulkParams {
+    libraryId: string;
+    recordsFilters: IRecordFilterLight[];
+    attributeId: string;
+    mapValues: Array<{
+        before: ITreeNode['id'] | null;
+        after: ITreeNode['id'] | null;
+    }>;
+    ctx: IQueryInfos;
+}
+export interface ISaveValueBulkTask {
+    saveValueBulk: (params: ISaveValueBulkParams, task?: ITaskFuncParams) => Promise<string>;
+}
+export interface ISaveValueBulkTaskDeps {
+    config: Config.IConfig;
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.tasksManager': ITasksManagerDomain;
+    'core.domain.record.helpers.findRecords': FindRecordsHelper;
+    'core.domain.notification': INotificationDomain;
+    translator: i18n;
+    'core.domain.value': IValueDomain;
+}
+export default function ({ config, 'core.domain.helpers.validate': validate, 'core.domain.attribute': attributeDomain, 'core.domain.tasksManager': tasksManagerDomain, 'core.domain.notification': notificationDomain, 'core.domain.record.helpers.findRecords': findRecordsHelper, 'core.domain.value': valueDomain, translator, }: ISaveValueBulkTaskDeps): ISaveValueBulkTask;

package/apps/core/src/domain/value/valueDomain.d.ts

@@ -11,20 +11,21 @@ import { type IValueRepo } from 'infra/value/valueRepo';
 import { type IUtils } from 'utils/utils';
 import { type ILogger } from '@leav/logger';
 import type * as Config from '_types/config';
-import { type IRecord } from '_types/record';
+import { type IRecordFilterLight, type IRecord } from '_types/record';
 import { type IAttribute } from '../../_types/attribute';
 import { type IQueryInfos } from '../../_types/queryInfos';
-import { type ISaveValue, type IValue, type IValuesOptions } from '../../_types/value';
+import { type IValueVersion, type ISaveValue, type IValue, type IValuesOptions, type IValuesOccurrencesResult } from '../../_types/value';
 import { type IActionsListDomain } from '../actionsList/actionsListDomain';
 import { type IAttributeDomain } from '../attribute/attributeDomain';
 import { type IValidateHelper } from '../helpers/validate';
 import { type IRecordAttributePermissionDomain } from '../permission/recordAttributePermissionDomain';
 import { type IRecordPermissionDomain } from '../permission/recordPermissionDomain';
-import { type IDeleteValueParams, type IRunActionListParams } from './_types';
+import { type IDeleteValueParams } from './_types';
 import { type DeleteRecordHelper } from 'domain/record/helpers/deleteRecord';
 import { type CreateRecordHelper } from 'domain/record/helpers/createRecord';
 import { type IfLibraryJoinLinkAttribute } from '../attribute/helpers/ifLibraryJoinLinkAttribute';
 import { type IRecordInCreationBypassHelper } from '../permission/helpers/recordInCreationBypass';
+import { type FindRecordsHelper } from 'domain/record/helpers/findRecords';
 export interface ISaveBatchValueError {
     type: string;
     message: string;
@@ -87,7 +88,34 @@ export interface IValueDomain {
         library: string;
         ctx: IQueryInfos;
     }): Promise<IValue>;
-    runActionsList(params: IRunActionListParams): Promise<IValue[]>;
+    /**
+     * Get the value of targeted attribute with actions applied on it including metadata.
+     *
+     * Avoid requesting DB if attribute already found in `record` param.
+     *
+     * @param {Object} params
+     * @param params.library
+     * @param params.record Could be emulated with only `{ id: <real_id> }`
+     * @param params.attributeId
+     * @param params.options
+     * @param params.ctx
+     */
+    getRecordFieldValue(params: {
+        library: string;
+        record: IRecord;
+        attributeId: string;
+        options?: IValuesOptions;
+        ctx: IQueryInfos;
+    }): Promise<IValue[]>;
+    countValuesOccurrences({ libraryId, attributeId, recordFilters, options, ctx, }: {
+        libraryId: string;
+        attributeId: string;
+        recordFilters: IRecordFilterLight[];
+        options?: {
+            version?: IValueVersion;
+        };
+        ctx: IQueryInfos;
+    }): Promise<IValuesOccurrencesResult>;
 }
 export interface IValueDomainDeps {
     config: Config.IConfig;
@@ -103,6 +131,7 @@ export interface IValueDomainDeps {
     'core.domain.record.helpers.sendRecordUpdateEvent': SendRecordUpdateEventHelper;
     'core.domain.record.helpers.createRecord': CreateRecordHelper;
     'core.domain.record.helpers.deleteRecord': DeleteRecordHelper;
+    'core.domain.record.helpers.findRecords': FindRecordsHelper;
     'core.domain.permission.helpers.recordInCreationBypass': IRecordInCreationBypassHelper;
     'core.domain.attribute.helpers.ifLibraryJoinLinkAttribute': IfLibraryJoinLinkAttribute;
     'core.domain.versionProfile': IVersionProfileDomain;
@@ -113,5 +142,5 @@ export interface IValueDomainDeps {
     'core.utils.logger': ILogger;
     'core.domain.tree': ITreeDomain;
 }
-declare const valueDomain: ({ config, "core.domain.actionsList": actionsListDomain, "core.domain.attribute": attributeDomain, "core.domain.permission.recordAttribute": recordAttributePermissionDomain, "core.domain.permission.record": recordPermissionDomain, "core.domain.eventsManager": eventsManager, "core.domain.helpers.validate": validate, "core.domain.helpers.updateRecordLastModif": updateRecordLastModif, "core.domain.tree.helpers.elementAncestors": elementAncestors, "core.domain.tree.helpers.getDefaultElement": getDefaultElementHelper, "core.domain.record.helpers.sendRecordUpdateEvent": sendRecordUpdateEvent, "core.domain.record.helpers.createRecord": createRecordHelper, "core.domain.permission.helpers.recordInCreationBypass": recordInCreationBypassHelper, "core.domain.record.helpers.deleteRecord": deleteRecordHelper, "core.domain.attribute.helpers.ifLibraryJoinLinkAttribute": ifLibraryJoinLinkAttribute, "core.domain.versionProfile": versionProfileDomain, "core.infra.record": recordRepo, "core.infra.tree": treeRepo, "core.infra.value": valueRepo, "core.utils": utils, "core.utils.logger": logger, }: IValueDomainDeps) => IValueDomain;
+declare const valueDomain: ({ config, "core.domain.actionsList": actionsListDomain, "core.domain.attribute": attributeDomain, "core.domain.permission.recordAttribute": recordAttributePermissionDomain, "core.domain.permission.record": recordPermissionDomain, "core.domain.eventsManager": eventsManager, "core.domain.helpers.validate": validate, "core.domain.helpers.updateRecordLastModif": updateRecordLastModif, "core.domain.tree.helpers.elementAncestors": elementAncestors, "core.domain.tree.helpers.getDefaultElement": getDefaultElementHelper, "core.domain.record.helpers.sendRecordUpdateEvent": sendRecordUpdateEvent, "core.domain.record.helpers.createRecord": createRecordHelper, "core.domain.record.helpers.findRecords": findRecordsHelper, "core.domain.permission.helpers.recordInCreationBypass": recordInCreationBypassHelper, "core.domain.record.helpers.deleteRecord": deleteRecordHelper, "core.domain.attribute.helpers.ifLibraryJoinLinkAttribute": ifLibraryJoinLinkAttribute, "core.domain.versionProfile": versionProfileDomain, "core.infra.record": recordRepo, "core.infra.tree": treeRepo, "core.infra.value": valueRepo, "core.utils": utils, "core.utils.logger": logger, }: IValueDomainDeps) => IValueDomain;
 export default valueDomain;

package/apps/core/src/infra/attributeTypes/attributeTypesRepo.d.ts

@@ -2,7 +2,7 @@ import { type AqlLiteral, type GeneratedAqlQuery } from 'arangojs/aql';
 import { type IQueryInfos } from '_types/queryInfos';
 import { AttributeTypes, type IAttribute } from '../../_types/attribute';
 import { AttributeCondition, type IRecordFilterOption } from '../../_types/record';
-import { type ISaveValueByAttributeType, type IValueByAttributeType, type IValuesOptions } from '../../_types/value';
+import { type IBaseValueByAttributeType, type IValuesOccurrences, type ISaveValueByAttributeType, type IValueByAttributeType, type IValuesOptions, type IValueVersion } from '../../_types/value';
 import { type IAttributeSimpleRepo } from './attributeSimpleRepo';
 import { type IAttributeSimpleLinkRepo } from './attributeSimpleLinkRepo';
 import { type IAttributeAdvancedRepo } from './attributeAdvancedRepo';
@@ -109,6 +109,15 @@ export interface IAttributeTypeRepo<AttributeType extends AttributeTypes = Attri
         forceGetAllValues: boolean;
         ctx: IQueryInfos;
     }): Promise<Value[][]>;
+    countValuesOccurrences?({ library, attribute, recordIds, options, ctx, }: {
+        library: string;
+        attribute: IAttribute;
+        recordIds: string[];
+        options?: {
+            version?: IValueVersion;
+        };
+        ctx: IQueryInfos;
+    }): Promise<IValuesOccurrences<IBaseValueByAttributeType[AttributeType]>>;
     /**
      * Return a specific value based on its ID. Field "id" is expect on the value
      *

package/apps/core/src/infra/db/migrations/013-passwordAttributeMaskValue.d.ts

@@ -0,0 +1,7 @@
+import { type IAttributeRepo } from 'infra/attribute/attributeRepo';
+import { type IMigration } from '../../../_types/migration';
+interface IDeps {
+    'core.infra.attribute'?: IAttributeRepo;
+}
+export default function ({ 'core.infra.attribute': attributeRepo }: IDeps): IMigration;
+export {};

package/apps/core/src/infra/value/valueRepo.d.ts

@@ -2,7 +2,7 @@ import { type IDbService } from 'infra/db/dbService';
 import { type IConfig } from '_types/config';
 import { type IAttribute } from '_types/attribute';
 import { type IQueryInfos } from '_types/queryInfos';
-import { type ISaveValue, type IValue } from '_types/value';
+import { type IValuesOccurrences, type ISaveValue, type IValue, type IValueVersion } from '_types/value';
 import { type IAttributeTypesRepo, type IAttributeWithRevLink, type IGetValuesOptions } from '../attributeTypes/attributeTypesRepo';
 export declare const VALUES_LINKS_COLLECTION = "core_edge_values_links";
 export declare const VALUES_COLLECTION = "core_values";
@@ -71,6 +71,15 @@ export interface IValueRepo {
         valueId: string;
         ctx: IQueryInfos;
     }): Promise<IValue>;
+    countValuesOccurrences?({ library, attribute, recordIds, options, ctx, }: {
+        library: string;
+        attribute: IAttribute;
+        recordIds: string[];
+        options?: {
+            version?: IValueVersion;
+        };
+        ctx: IQueryInfos;
+    }): Promise<IValuesOccurrences>;
     clearAllValues({ attribute, ctx }: {
         attribute: IAttribute;
         ctx: IQueryInfos;

package/libs/logger/src/config.d.ts

@@ -49,5 +49,5 @@ export interface ILoggerConfig {
     };
     onErrorLog?: (message: string, meta: any, getCallStackTrace: () => string) => void;
 }
-export declare function envToBool(value: string, defaultValue?: boolean): boolean;
-export declare const defaultLoggerConfig: ILoggerConfig & Required<Omit<ILoggerConfig, 'onErrorLog'>>;
+export declare function envToBool(value?: string, defaultValue?: boolean): boolean;
+export declare const defaultLoggerConfig: ILoggerConfig & Required<Omit<ILoggerConfig, 'onErrorLog' | 'destinationFile'>>;

package/libs/utils/src/types/files.d.ts

@@ -12,5 +12,5 @@ export interface IPreviewScalar {
     pdf?: string;
     file: FileRecord;
     original: string;
-    [key: string]: string | FileRecord;
+    [key: string]: string | FileRecord | undefined;
 }

package/libs/utils/src/utils.d.ts

@@ -29,10 +29,8 @@ export declare const objectToNameValueArray: <T>(obj: IKeyValue<T>) => Array<{
     name: string;
     value: T;
 }>;
-export declare const nameValArrayToObj: (arr?: Array<{}>, keyFieldName?: string, valueFieldName?: string) => {
-    [key: string]: any;
-};
-export declare const getFileType: (fileName: string) => FileType;
+export declare const nameValArrayToObj: (arr?: Array<Record<string, any>>, keyFieldName?: string, valueFieldName?: string) => Record<string, any> | null;
+export declare const getFileType: (fileName: string) => FileType | null;
 /**
  * Return a simplified call stack (for the function who called this function, not this one, obviously)
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aristid/leav-types",
-  "version": "1.5.0",
+  "version": "1.5.1-1929c505",
   "description": "Shared Leav types",
   "scripts": {
     "tscheck": "",
@@ -14,7 +14,7 @@
   "license": "LGPL3",
   "repository": "https://github.com/leav-solutions/leav-engine",
   "dependencies": {
-    "@leav/utils": "1.5.0",
+    "@leav/utils": "1.5.1",
     "@types/amqplib": "0.10.7",
     "@types/express": "5.0.0",
     "@types/jest": "29.5.14",