@aristid/leav-types 0.0.7-ce462f0 → 0.0.7-ceed596d

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

@@ -1,6 +1,6 @@
 import { AdminPermissionsActions, ApplicationPermissionsActions, AttributePermissionsActions, IPermissionsTreeTarget, ITreePermissionsConf, LibraryPermissionsActions, PermissionsActions, PermissionTypes, RecordAttributePermissionsActions, RecordPermissionsActions, TreeNodePermissionsActions, TreePermissionsActions } from '_types/permissions';
 import { IQueryInfos } from '_types/queryInfos';
-import { TreePaths } from '_types/tree';
+import { TreePath } from '_types/tree';
 export declare const PERMISSIONS_CACHE_HEADER = "permissions";
 export declare const PERMISSIONS_NULL_PLACEHOLDER = "__null__";
 export interface IPermissionTarget {
@@ -28,14 +28,6 @@ export interface IGetPermissionsByActionsParams {
 export type PermByActionsRes = {
     [name: string]: boolean | null;
 } | null;
-export interface IGetPermissionByUserGroupsParams {
-    type: PermissionTypes;
-    action: PermissionsActions;
-    userGroupsPaths: TreePaths[];
-    applyTo?: string;
-    permissionTreeTarget?: IPermissionsTreeTarget;
-    ctx: IQueryInfos;
-}
 export interface IGetAdminPermissionParams {
     action: AdminPermissionsActions;
     userId: string;
@@ -63,7 +55,7 @@ export interface IGetTreeLibraryPermissionParams {
     treeId: string;
     libraryId: string;
     userId: string;
-    getDefaultPermission?: (params?: IGetDefaultTreeLibraryPermissionParams) => boolean | null;
+    getDefaultPermission?: (params?: IGetDefaultTreeLibraryPermissionParams) => Promise<boolean> | boolean;
     ctx: IQueryInfos;
 }
 export interface IGetApplicationPermissionParams {
@@ -171,7 +163,7 @@ export interface IGetDefaultPermissionParams {
     action?: any;
     applyTo?: string;
     userId?: string;
-    userGroups?: TreePaths[];
+    userGroups?: TreePath[];
 }
 export interface IGetTreeBasedPermissionParams {
     type: PermissionTypes;
@@ -207,3 +199,11 @@ export interface IGetInheritedRecordPermissionParams {
     permTreeNode: string;
     ctx: IQueryInfos;
 }
+export interface IEstimateTreeValueRecordPermissionParams {
+    action: RecordPermissionsActions;
+    userId: string;
+    libraryId: string;
+    attributeId: string;
+    nodeId: string;
+    ctx: IQueryInfos;
+}

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

@@ -1,18 +1,13 @@
-import { IAttributeRepo } from 'infra/attribute/attributeRepo';
-import { IPermissionRepo } from 'infra/permission/permissionRepo';
-import { ITreeRepo } from 'infra/tree/treeRepo';
-import { IValueRepo } from 'infra/value/valueRepo';
 import { IQueryInfos } from '_types/queryInfos';
-import { ICachesService } from '../../../infra/cache/cacheService';
 import { PermissionsActions, PermissionTypes } from '../../../_types/permissions';
 import { IDefaultPermissionHelper } from './defaultPermission';
 import { IPermissionByUserGroupsHelper } from './permissionByUserGroups';
+import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
 interface IGetGlobalPermissionParams {
     type: PermissionTypes;
     applyTo?: string;
-    userId: string;
     action: PermissionsActions;
-    getDefaultPermission?: (params?: IGetDefaultGlobalPermissionParams) => boolean;
+    getDefaultPermission?: (params?: IGetDefaultGlobalPermissionParams) => Promise<boolean> | boolean;
 }
 interface IGetInheritedGlobalPermissionParams {
     type: PermissionTypes;
@@ -35,11 +30,7 @@ export interface IGlobalPermissionHelper {
 export interface IGlobalPermissionDeps {
     'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
     'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
-    'core.infra.permission': IPermissionRepo;
-    'core.infra.attribute': IAttributeRepo;
-    'core.infra.tree': ITreeRepo;
-    'core.infra.value': IValueRepo;
-    'core.infra.cache.cacheService': ICachesService;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
 }
-export default function ({ 'core.domain.permission.helpers.permissionByUserGroups': permByUserGroupsHelper, 'core.domain.permission.helpers.defaultPermission': defaultPermHelper, 'core.infra.attribute': attributeRepo, 'core.infra.value': valueRepo, 'core.infra.tree': treeRepo, 'core.infra.cache.cacheService': cacheService }: IGlobalPermissionDeps): IGlobalPermissionHelper;
+export default function ({ 'core.domain.permission.helpers.permissionByUserGroups': permByUserGroupsHelper, 'core.domain.permission.helpers.defaultPermission': defaultPermHelper, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper }: IGlobalPermissionDeps): IGlobalPermissionHelper;
 export {};

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

@@ -1,14 +1,32 @@
-import { IPermissionRepo } from 'infra/permission/permissionRepo';
-import { IGetPermissionByUserGroupsParams } from '../_types';
 import { IReducePermissionsArrayHelper } from './reducePermissionsArray';
 import { ISimplePermissionHelper } from './simplePermission';
-interface IDeps {
+import { IDefaultPermissionHelper } from './defaultPermission';
+import { TreePath } from '../../../_types/tree';
+import { PermissionsActions, PermissionTypes } from '../../../_types/permissions';
+import { IQueryInfos } from '../../../_types/queryInfos';
+import { ICachesService } from '../../../infra/cache/cacheService';
+import { IConfig } from '_types/config';
+export interface IPermissionByUserGroupsHelperDeps {
     'core.domain.permission.helpers.simplePermission': ISimplePermissionHelper;
     'core.domain.permission.helpers.reducePermissionsArray': IReducePermissionsArrayHelper;
-    'core.infra.permission'?: IPermissionRepo;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.infra.cache.cacheService': ICachesService;
+    config: IConfig;
+}
+interface IGetPermissionByUserGroupsParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userGroupsPaths: TreePath[];
+    applyTo?: string;
+    treeTarget?: {
+        tree: string;
+        path: TreePath;
+    };
+    getDefaultPermission?: () => Promise<boolean> | boolean;
+    ctx: IQueryInfos;
 }
 export interface IPermissionByUserGroupsHelper {
-    getPermissionByUserGroups: (params: IGetPermissionByUserGroupsParams) => Promise<boolean | null>;
+    getPermissionByUserGroups: (params: IGetPermissionByUserGroupsParams) => Promise<boolean>;
 }
-export default function (deps: IDeps): IPermissionByUserGroupsHelper;
+export default function (deps: IPermissionByUserGroupsHelperDeps): IPermissionByUserGroupsHelper;
 export {};

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

@@ -1,4 +1,4 @@
 export interface IReducePermissionsArrayHelper {
-    reducePermissionsArray: (permissions: Array<boolean | null>) => boolean | null;
+    reducePermissionsArray: (permissions: boolean[]) => boolean;
 }
 export default function (): IReducePermissionsArrayHelper;

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

@@ -2,19 +2,15 @@ import { IAttributeDomain } from 'domain/attribute/attributeDomain';
 import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
 import { IPermissionRepo } from 'infra/permission/permissionRepo';
 import { IQueryInfos } from '_types/queryInfos';
-import { ICachesService } from '../../../infra/cache/cacheService';
 import { IGetInheritedTreeBasedPermissionParams, IGetTreeBasedPermissionParams } from '../_types';
-import { IDefaultPermissionHelper } from './defaultPermission';
 import { IPermissionByUserGroupsHelper } from './permissionByUserGroups';
 import { IReducePermissionsArrayHelper } from './reducePermissionsArray';
 export interface ITreeBasedPermissionsDeps {
     'core.domain.attribute': IAttributeDomain;
     'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
-    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
     'core.domain.permission.helpers.reducePermissionsArray': IReducePermissionsArrayHelper;
     'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.infra.permission': IPermissionRepo;
-    'core.infra.cache.cacheService': ICachesService;
 }
 export interface ITreeBasedPermissionHelper {
     getTreeBasedPermission(params: IGetTreeBasedPermissionParams, ctx: IQueryInfos): Promise<boolean>;

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

@@ -25,6 +25,7 @@ export interface IPermissionDomain {
     isAllowed({ type, action, userId, applyTo, target, ctx }: IIsAllowedParams): Promise<boolean>;
     getActionsByType(params: IGetActionsByTypeParams): ILabeledPermissionsAction[];
     registerActions(type: PermissionTypes, actions: string[], applyOn?: string[]): void;
+    isAdminOrSystemUser(ctx: IQueryInfos): boolean;
 }
 export interface IPermissionDomainDeps {
     'core.domain.permission.admin': IAdminPermissionDomain;

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

@@ -5,10 +5,12 @@ import { IDefaultPermissionHelper } from './helpers/defaultPermission';
 import { IPermissionByUserGroupsHelper } from './helpers/permissionByUserGroups';
 import { ITreeBasedPermissionHelper } from './helpers/treeBasedPermissions';
 import { ILibraryPermissionDomain } from './libraryPermissionDomain';
-import { IGetInheritedRecordPermissionParams, IGetRecordPermissionParams } from './_types';
+import { IGetInheritedRecordPermissionParams, IGetRecordPermissionParams, IEstimateTreeValueRecordPermissionParams } from './_types';
+import { ITreeRepo } from '../../infra/tree/treeRepo';
 export interface IRecordPermissionDomain {
     getRecordPermission(params: IGetRecordPermissionParams): Promise<boolean>;
     getInheritedRecordPermission(params: IGetInheritedRecordPermissionParams): Promise<boolean>;
+    evaluateTreeValueRecordPermission(params: IEstimateTreeValueRecordPermissionParams): Promise<boolean>;
 }
 export interface IRecordPermissionDomainDeps {
     'core.domain.permission.library': ILibraryPermissionDomain;
@@ -18,5 +20,6 @@ export interface IRecordPermissionDomainDeps {
     'core.domain.attribute': IAttributeDomain;
     'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
     'core.infra.value': IValueRepo;
+    'core.infra.tree': ITreeRepo;
 }
 export default function (deps: IRecordPermissionDomainDeps): IRecordPermissionDomain;

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

@@ -2,12 +2,12 @@ import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
 import { ITreeRepo } from 'infra/tree/treeRepo';
 import { IValueRepo } from 'infra/value/valueRepo';
 import { IAttributeDomain } from '../attribute/attributeDomain';
-import { IDefaultPermissionHelper } from './helpers/defaultPermission';
 import { IPermissionByUserGroupsHelper } from './helpers/permissionByUserGroups';
 import { ITreeBasedPermissionHelper } from './helpers/treeBasedPermissions';
 import { ITreeLibraryPermissionDomain } from './treeLibraryPermissionDomain';
 import { ITreePermissionDomain } from './treePermissionDomain';
 import { IGetInheritedTreeNodePermissionParams, IGetTreeNodePermissionParams } from './_types';
+import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
 export interface ITreeNodePermissionDomain {
     getTreeNodePermission(params: IGetTreeNodePermissionParams): Promise<boolean>;
     getInheritedTreeNodePermission(params: IGetInheritedTreeNodePermissionParams): Promise<boolean>;
@@ -17,7 +17,7 @@ export interface ITreeNodePermissionDomainDeps {
     'core.domain.permission.treeLibrary': ITreeLibraryPermissionDomain;
     'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
     'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
-    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
     'core.infra.tree': ITreeRepo;
     'core.domain.attribute': IAttributeDomain;

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

@@ -1,4 +1,5 @@
 import { ErrorTypes } from '@leav/utils';
+import { Errors } from '_types/errors';
 import { ICursorPaginationParams, IPaginationParams } from '_types/list';
 import { IRecord, IRecordFilterLight, IRecordSortLight } from '_types/record';
 import { IValue, IValuesOptions, IValueVersion } from '_types/value';
@@ -11,6 +12,7 @@ export interface IFindRecordParams {
     withCount?: boolean;
     retrieveInactive?: boolean;
     fulltextSearch?: string;
+    ignorePermissions?: boolean;
 }
 export interface ICreateRecordParams {
     library: string;
@@ -20,10 +22,9 @@ export interface ICreateRecordParams {
     };
 }
 export interface ICreateRecordValueError {
-    attributeId: string;
-    type: ErrorTypes;
+    attribute: string;
+    type: ErrorTypes | Errors;
     message: string;
-    id_value?: string;
     input?: any;
 }
 export interface ICreateRecordResult {

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

@@ -0,0 +1,22 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { ILibraryPermissionDomain } from 'domain/permission/libraryPermissionDomain';
+import { IRecordRepo } from 'infra/record/recordRepo';
+import { IQueryInfos } from '../../../_types/queryInfos';
+import { ICreateRecordResult, ICreateRecordValueError } from '../_types';
+export type IPreCreateRecordCallback = () => Promise<ICreateRecordValueError[]>;
+export type CreateRecordHelper = (params: {
+    library: string;
+    /**
+     * Can be use to validate potential values to post create insert to record
+     */
+    preCreateCallback?: IPreCreateRecordCallback;
+    ctx: IQueryInfos;
+    active?: boolean;
+}) => Promise<ICreateRecordResult>;
+interface IDeps {
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.permission.library': ILibraryPermissionDomain;
+    'core.infra.record': IRecordRepo;
+}
+export default function ({ 'core.domain.eventsManager': eventsManager, 'core.domain.permission.library': libraryPermissionDomain, 'core.infra.record': recordRepo }: IDeps): CreateRecordHelper;
+export {};

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

@@ -0,0 +1,19 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { IQueryInfos } from '../../../_types/queryInfos';
+import { IRecordPermissionDomain } from 'domain/permission/recordPermissionDomain';
+import { IValidateHelper } from 'domain/helpers/validate';
+import { IRecordRepo } from 'infra/record/recordRepo';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IValueRepo } from 'infra/value/valueRepo';
+import { IRecord } from '../../../_types/record';
+export type DeleteRecordHelper = (library: string, id: string, ctx: IQueryInfos) => Promise<IRecord>;
+interface IDeps {
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.permission.record': IRecordPermissionDomain;
+    'core.infra.record': IRecordRepo;
+    'core.infra.tree': ITreeRepo;
+    'core.infra.value': IValueRepo;
+}
+export default function ({ 'core.domain.eventsManager': eventsManager, 'core.domain.helpers.validate': validateHelper, 'core.domain.permission.record': recordPermissionDomain, 'core.infra.record': recordRepo, 'core.infra.tree': treeRepo, 'core.infra.value': valueRepo }: IDeps): DeleteRecordHelper;
+export {};

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

@@ -0,0 +1,24 @@
+import { IAttribute } from '_types/attribute';
+import { IQueryInfos } from '_types/queryInfos';
+import { ITreeNode } from '_types/tree';
+import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+import { IPermissionRepo } from 'infra/permission/permissionRepo';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IDefaultPermissionHelper } from 'domain/permission/helpers/defaultPermission';
+interface IAccessPermissionFilterDeps {
+    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
+    'core.infra.tree': ITreeRepo;
+    'core.infra.permission': IPermissionRepo;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+}
+export interface IGetAccessPermissionsValue {
+    treeId: string;
+    attribute: IAttribute;
+    permissions: {
+        true: Array<ITreeNode['id']>;
+        false: Array<ITreeNode['id']>;
+    };
+}
+export type IGetAccessPermissions = (groupsIds: string[][], library: string, deps: IAccessPermissionFilterDeps, ctx: IQueryInfos) => Promise<IGetAccessPermissionsValue[]>;
+declare const getAccessPermissionsFilters: IGetAccessPermissions;
+export default getAccessPermissionsFilters;

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

@@ -1 +1,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';

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

@@ -11,7 +11,7 @@ import { IValueRepo } from 'infra/value/valueRepo';
 import { IUtils } from 'utils/utils';
 import * as Config from '_types/config';
 import { IListWithCursor } from '_types/list';
-import { IValue, IValuesOptions } from '_types/value';
+import { ISaveValue, IValue, IValuesOptions } from '_types/value';
 import { ICachesService } from '../../infra/cache/cacheService';
 import { IQueryInfos } from '../../_types/queryInfos';
 import { IRecord, IRecordFilterLight, IRecordIdentity } from '../../_types/record';
@@ -20,10 +20,25 @@ import { IRecordPermissionDomain } from '../permission/recordPermissionDomain';
 import { SendRecordUpdateEventHelper } from './helpers/sendRecordUpdateEvent';
 import { ICreateRecordResult, IFindRecordParams } from './_types';
 import { IFormRepo } from 'infra/form/formRepo';
+import { IRecordAttributePermissionDomain } from '../permission/recordAttributePermissionDomain';
+import { IAttributePermissionDomain } from '../permission/attributePermissionDomain';
+import { IPermissionRepo } from '../../infra/permission/permissionRepo';
+import { IDefaultPermissionHelper } from 'domain/permission/helpers/defaultPermission';
+import { DeleteRecordHelper } from './helpers/deleteRecord';
+import { CreateRecordHelper } from './helpers/createRecord';
+import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
 export interface IRecordDomain {
+    /**
+     * Create empty record
+     * Used when create a record, set active to false and inCreation to true
+     */
+    createEmptyRecord(params: {
+        library: string;
+        ctx: IQueryInfos;
+    }): Promise<ICreateRecordResult>;
     createRecord(params: {
         library: string;
-        values?: IValue[];
+        values?: ISaveValue[];
         verifyRequiredAttributes?: boolean;
         ctx: IQueryInfos;
     }): Promise<ICreateRecordResult>;
@@ -78,6 +93,12 @@ export interface IRecordDomain {
         filters?: IRecordFilterLight[];
         ctx: IQueryInfos;
     }): Promise<IRecord[]>;
+    activateRecordsBatch(params: {
+        libraryId: string;
+        recordsIds?: string[];
+        filters?: IRecordFilterLight[];
+        ctx: IQueryInfos;
+    }): Promise<IRecord[]>;
     purgeInactiveRecords(params: {
         libraryId: string;
         ctx: IQueryInfos;
@@ -90,16 +111,23 @@ export interface IRecordDomainDeps {
     'core.domain.value': IValueDomain;
     'core.domain.permission.record': IRecordPermissionDomain;
     'core.domain.permission.library': ILibraryPermissionDomain;
+    'core.domain.permission.attribute': IAttributePermissionDomain;
+    '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.sendRecordUpdateEvent': SendRecordUpdateEventHelper;
     'core.infra.library': ILibraryRepo;
     'core.infra.tree': ITreeRepo;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.infra.value': IValueRepo;
     'core.infra.form': IFormRepo;
+    'core.infra.permission': IPermissionRepo;
     'core.domain.eventsManager': IEventsManagerDomain;
     'core.infra.cache.cacheService': ICachesService;
     '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.helpers.getCoreEntityById': getCoreEntityById, 'core.domain.helpers.validate': validateHelper, 'core.domain.record.helpers.sendRecordUpdateEvent': sendRecordUpdateEvent, 'core.infra.library': libraryRepo, 'core.infra.tree': treeRepo, 'core.infra.value': valueRepo, 'core.infra.form': formRepo, 'core.domain.eventsManager': eventsManager, 'core.infra.cache.cacheService': cacheService, '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.permission.library': libraryPermissionDomain, 'core.domain.permission.attribute': attrPermissionDomain, '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.value': valueRepo, 'core.infra.form': formRepo, 'core.infra.permission': permissionRepo, 'core.domain.eventsManager': eventsManager, 'core.infra.cache.cacheService': cacheService, 'core.utils': utils, translator }: IRecordDomainDeps): IRecordDomain;

package/apps/core/src/domain/tree/treeDomain.d.ts

@@ -11,7 +11,7 @@ import { IQueryInfos } from '_types/queryInfos';
 import { ICachesService } from '../../infra/cache/cacheService';
 import { IList, IPaginationParams } from '../../_types/list';
 import { IRecord } from '../../_types/record';
-import { IGetCoreTreesParams, ITree, ITreeElement, ITreeNode, ITreeNodeLight, TreePaths } from '../../_types/tree';
+import { IGetCoreTreesParams, ITree, ITreeElement, ITreeNode, ITreeNodeLight, TreePath } from '../../_types/tree';
 import { IAttributeDomain } from '../attribute/attributeDomain';
 import { IRecordDomain } from '../record/recordDomain';
 import { IElementAncestorsHelper } from './helpers/elementAncestors';
@@ -112,7 +112,7 @@ export interface ITreeDomain {
         treeId: string;
         nodeId: string;
         ctx: IQueryInfos;
-    }): Promise<TreePaths>;
+    }): Promise<TreePath>;
     /**
      * Retrieve all records linked to an element via given attribute
      */

package/apps/core/src/domain/value/helpers/{canSaveValue.d.ts → canSaveRecordValue.d.ts}

@@ -6,12 +6,12 @@ import { IQueryInfos } from '_types/queryInfos';
 import { IValue } from '_types/value';
 import { ErrorFieldDetail, Errors } from '../../../_types/errors';
 import { RecordAttributePermissionsActions, RecordPermissionsActions } from '../../../_types/permissions';
-interface ICanSaveValueRes {
+interface ICanSaveRecordValueRes {
     canSave: boolean;
     reason?: RecordAttributePermissionsActions | RecordPermissionsActions | Errors;
     fields?: ErrorFieldDetail<IValue>;
 }
-interface ICanSaveValueParams {
+interface ICanSaveRecordValueParams {
     attributeProps: IAttribute;
     value: IValue;
     library: string;
@@ -24,5 +24,5 @@ interface ICanSaveValueParams {
         config: IConfig;
     };
 }
-declare const _default: (params: ICanSaveValueParams) => Promise<ICanSaveValueRes>;
+declare const _default: (params: ICanSaveRecordValueParams) => Promise<ICanSaveRecordValueRes>;
 export default _default;

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

@@ -0,0 +1,5 @@
+import { IValue, EmptyValue } from '_types/value';
+declare const _default: (value: IValue) => value is IValue & {
+    payload: EmptyValue;
+};
+export default _default;

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

@@ -3,10 +3,10 @@ import { IAttributeDomain } from 'domain/attribute/attributeDomain';
 import { IUtils } from 'utils/utils';
 import { IAttribute } from '_types/attribute';
 import { IQueryInfos } from '_types/queryInfos';
-import { IValue } from '_types/value';
+import { ISaveValue } from '_types/value';
 interface IPrepareValueParams {
     attributeProps: IAttribute;
-    value: IValue;
+    value: ISaveValue;
     library: string;
     recordId: string;
     infos?: IQueryInfos;
@@ -18,5 +18,5 @@ interface IPrepareValueParams {
     };
     ctx: IQueryInfos;
 }
-declare const _default: (params: IPrepareValueParams) => Promise<IValue[]>;
+declare const _default: (params: IPrepareValueParams) => Promise<ISaveValue[]>;
 export default _default;

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

@@ -7,7 +7,7 @@ import { ITreeRepo } from 'infra/tree/treeRepo';
 import { IValueRepo } from 'infra/value/valueRepo';
 import { IQueryInfos } from '_types/queryInfos';
 import { IAttribute } from '../../../_types/attribute';
-import { IValue } from '../../../_types/value';
+import { ISaveValue, IValue } from '../../../_types/value';
 interface ISaveOneValueDeps {
     valueRepo: IValueRepo;
     recordRepo: IRecordRepo;
@@ -17,5 +17,5 @@ interface ISaveOneValueDeps {
     attributeDomain: IAttributeDomain;
     versionProfileDomain: IVersionProfileDomain;
 }
-declare const _default: (library: string, recordId: string, attribute: IAttribute, value: IValue, deps: ISaveOneValueDeps, ctx: IQueryInfos) => Promise<IValue>;
+declare const _default: (library: string, recordId: string, attribute: IAttribute, value: ISaveValue, deps: ISaveOneValueDeps, ctx: IQueryInfos) => Promise<IValue>;
 export default _default;

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

@@ -5,12 +5,12 @@ import { IValueRepo } from 'infra/value/valueRepo';
 import { IAttribute } from '../../../_types/attribute';
 import { ErrorFieldDetail } from '../../../_types/errors';
 import { IQueryInfos } from '../../../_types/queryInfos';
-import { IValue } from '../../../_types/value';
+import { ISaveValue } from '../../../_types/value';
 interface IValidateValueParams {
     attributeProps: IAttribute;
-    value: IValue;
+    value: ISaveValue;
     library: string;
-    recordId: string;
+    recordId?: string;
     infos?: IQueryInfos;
     keepEmpty: boolean;
     deps: {
@@ -21,5 +21,5 @@ interface IValidateValueParams {
     };
     ctx: IQueryInfos;
 }
-declare const _default: (params: IValidateValueParams) => Promise<ErrorFieldDetail<IValue>>;
+declare const _default: (params: IValidateValueParams) => Promise<ErrorFieldDetail<ISaveValue>>;
 export default _default;

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

@@ -14,13 +14,16 @@ import * as Config from '_types/config';
 import { IRecord } from '_types/record';
 import { IAttribute } from '../../_types/attribute';
 import { IQueryInfos } from '../../_types/queryInfos';
-import { IValue, IValuesOptions } from '../../_types/value';
+import { ISaveValue, IValue, IValuesOptions } from '../../_types/value';
 import { IActionsListDomain } from '../actionsList/actionsListDomain';
 import { IAttributeDomain } from '../attribute/attributeDomain';
 import { IValidateHelper } from '../helpers/validate';
 import { IRecordAttributePermissionDomain } from '../permission/recordAttributePermissionDomain';
 import { IRecordPermissionDomain } from '../permission/recordPermissionDomain';
 import { IDeleteValueParams, IRunActionListParams } from './_types';
+import { DeleteRecordHelper } from 'domain/record/helpers/deleteRecord';
+import { CreateRecordHelper } from 'domain/record/helpers/createRecord';
+import { IfLibraryJoinLinkAttribute } from '../attribute/helpers/ifLibraryJoinLinkAttribute';
 export interface ISaveBatchValueError {
     type: string;
     message: string;
@@ -58,7 +61,7 @@ export interface IValueDomain {
         library: string;
         recordId: string;
         attribute: string;
-        value: IValue;
+        value: ISaveValue;
         ctx: IQueryInfos;
     }): Promise<IValue[]>;
     /**
@@ -70,9 +73,10 @@ export interface IValueDomain {
     saveValueBatch(params: {
         library: string;
         recordId: string;
-        values: IValue[];
+        values: ISaveValue[];
         ctx: IQueryInfos;
         keepEmpty?: boolean;
+        skipPermission?: boolean;
     }): Promise<ISaveBatchValueResult>;
     deleteValue(params: IDeleteValueParams): Promise<IValue[]>;
     formatValue(params: {
@@ -101,6 +105,9 @@ export interface IValueDomainDeps {
     'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
     'core.domain.tree.helpers.getDefaultElement': IGetDefaultElementHelper;
     'core.domain.record.helpers.sendRecordUpdateEvent': SendRecordUpdateEventHelper;
+    'core.domain.record.helpers.createRecord': CreateRecordHelper;
+    'core.domain.record.helpers.deleteRecord': DeleteRecordHelper;
+    'core.domain.attribute.helpers.ifLibraryJoinLinkAttribute': IfLibraryJoinLinkAttribute;
     'core.domain.versionProfile': IVersionProfileDomain;
     'core.infra.record': IRecordRepo;
     'core.infra.tree': ITreeRepo;
@@ -109,5 +116,5 @@ export interface IValueDomainDeps {
     'core.utils.logger': winston.Winston;
     '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.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.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/errors/LeavError.d.ts

@@ -14,6 +14,12 @@ export default class LeavError<T, E = ErrorTypes> extends Error {
     fields?: ErrorFieldDetail<T>;
     type: E;
     record?: ILeavErrorRecord;
+    /**
+     * Use this ID to identify the error in logs or for debugging purposes.
+     * It is generated using uuid v1, which includes a timestamp and a unique identifier.
+     * This allows for tracking the error across different systems and logs.
+     */
+    errorId: string;
     constructor(type: E, message?: string, details?: ILeavErrorDetails);
 }
 export {};

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

@@ -1,16 +1,19 @@
 import { IFilterTypesHelper } from 'infra/record/helpers/filterTypes';
 import { IUtils } from 'utils/utils';
+import { AttributeTypes } from '../../_types/attribute';
 import { IDbService } from '../db/dbService';
 import { IDbUtils } from '../db/dbUtils';
 import { IAttributeTypeRepo } from './attributeTypesRepo';
 import { GetConditionPart } from './helpers/getConditionPart';
+import { IAttributeSimpleLinkRepo } from './attributeSimpleLinkRepo';
+export type IAttributeAdvancedLinkRepo = IAttributeTypeRepo<AttributeTypes.ADVANCED_LINK>;
 interface IDeps {
     'core.infra.db.dbService'?: IDbService;
     'core.infra.db.dbUtils'?: IDbUtils;
-    'core.infra.attributeTypes.attributeSimpleLink'?: IAttributeTypeRepo;
+    'core.infra.attributeTypes.attributeSimpleLink'?: IAttributeSimpleLinkRepo;
     'core.infra.attributeTypes.helpers.getConditionPart'?: GetConditionPart;
     'core.infra.record.helpers.filterTypes'?: IFilterTypesHelper;
     'core.utils'?: IUtils;
 }
-export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.infra.attributeTypes.attributeSimpleLink': attributeSimpleLinkRepo, 'core.infra.attributeTypes.helpers.getConditionPart': getConditionPart, 'core.infra.record.helpers.filterTypes': filterTypes, 'core.utils': utils }?: IDeps): IAttributeTypeRepo;
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.infra.attributeTypes.attributeSimpleLink': attributeSimpleLinkRepo, 'core.infra.attributeTypes.helpers.getConditionPart': getConditionPart, 'core.infra.record.helpers.filterTypes': filterTypes, 'core.utils': utils }?: IDeps): IAttributeAdvancedLinkRepo;
 export {};

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

@@ -1,5 +1,6 @@
 import { IDbUtils } from 'infra/db/dbUtils';
 import { IFilterTypesHelper } from 'infra/record/helpers/filterTypes';
+import { AttributeTypes } from '../../_types/attribute';
 import { IDbService } from '../db/dbService';
 import { IAttributeTypeRepo } from './attributeTypesRepo';
 import { GetConditionPart } from './helpers/getConditionPart';
@@ -9,4 +10,5 @@ export interface IAttributeAdvancedRepoDeps {
     'core.infra.attributeTypes.helpers.getConditionPart': GetConditionPart;
     'core.infra.record.helpers.filterTypes': IFilterTypesHelper;
 }
-export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.infra.attributeTypes.helpers.getConditionPart': getConditionPart, 'core.infra.record.helpers.filterTypes': filterTypesHelper }: IAttributeAdvancedRepoDeps): IAttributeTypeRepo;
+export type IAttributeAdvancedRepo = IAttributeTypeRepo<AttributeTypes.ADVANCED>;
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.infra.attributeTypes.helpers.getConditionPart': getConditionPart, 'core.infra.record.helpers.filterTypes': filterTypesHelper }: IAttributeAdvancedRepoDeps): IAttributeAdvancedRepo;