@aristid/leav-types 0.0.7 → 1.0.0-e073ed8e

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

@@ -0,0 +1,25 @@
+import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+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 { ILibraryPermissionDomain } from './libraryPermissionDomain';
+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;
+    'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
+    'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    '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/recordPermissionDomain.spec.d.ts

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

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

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetInheritedTreeLibraryPermissionParams, IGetTreeLibraryPermissionParams } from './_types';
+export interface ITreeLibraryPermissionDomain {
+    getTreeLibraryPermission(params: IGetTreeLibraryPermissionParams): Promise<boolean>;
+    getInheritedTreeLibraryPermission(params: IGetInheritedTreeLibraryPermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function ({ 'core.domain.permission.helpers.globalPermission': globalPermHelper }: IDeps): ITreeLibraryPermissionDomain;
+export {};

package/apps/core/src/domain/permission/treeLibraryPermissionDomain.spec.d.ts

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

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

@@ -0,0 +1,26 @@
+import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IValueRepo } from 'infra/value/valueRepo';
+import { IAttributeDomain } from '../attribute/attributeDomain';
+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>;
+}
+export interface ITreeNodePermissionDomainDeps {
+    'core.domain.permission.tree': ITreePermissionDomain;
+    'core.domain.permission.treeLibrary': ITreeLibraryPermissionDomain;
+    'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
+    'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
+    'core.infra.tree': ITreeRepo;
+    'core.domain.attribute': IAttributeDomain;
+    'core.infra.value': IValueRepo;
+}
+export default function (deps: ITreeNodePermissionDomainDeps): ITreeNodePermissionDomain;

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

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

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

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetInheritedTreePermissionParams, IGetTreePermissionParams } from './_types';
+export interface ITreePermissionDomain {
+    getTreePermission(params: IGetTreePermissionParams): Promise<boolean>;
+    getInheritedTreePermission(params: IGetInheritedTreePermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function ({ 'core.domain.permission.helpers.globalPermission': globalPermHelper }: IDeps): ITreePermissionDomain;
+export {};

package/apps/core/src/domain/permission/treePermissionDomain.spec.d.ts

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

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

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

package/apps/core/src/domain/plugins/pluginsDomain.d.ts

@@ -0,0 +1,11 @@
+import { IPluginsRepo } from 'infra/plugins/pluginsRepo';
+import { IPluginInfos, IRegisteredPlugin } from '_types/plugin';
+interface IDeps {
+    'core.infra.plugins': IPluginsRepo;
+}
+export interface IPluginsDomain {
+    registerPlugin(path: string, plugin: IPluginInfos): IRegisteredPlugin;
+    getRegisteredPlugins(): IRegisteredPlugin[];
+}
+export default function ({ 'core.infra.plugins': pluginsRepo }: IDeps): IPluginsDomain;
+export {};

package/apps/core/src/domain/plugins/pluginsDomain.spec.d.ts

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

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

@@ -0,0 +1,33 @@
+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';
+export interface IFindRecordParams {
+    library: string;
+    filters?: IRecordFilterLight[];
+    sort?: IRecordSortLight[];
+    options?: IValuesOptions;
+    pagination?: IPaginationParams | ICursorPaginationParams;
+    withCount?: boolean;
+    retrieveInactive?: boolean;
+    fulltextSearch?: string;
+    ignorePermissions?: boolean;
+}
+export interface ICreateRecordParams {
+    library: string;
+    data?: {
+        values: IValue[];
+        version: IValueVersion;
+    };
+}
+export interface ICreateRecordValueError {
+    attribute: string;
+    type: ErrorTypes | Errors;
+    message: string;
+    input?: any;
+}
+export interface ICreateRecordResult {
+    record?: IRecord;
+    valuesErrors?: ICreateRecordValueError[];
+}

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

@@ -0,0 +1,30 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { ILibraryRepo } from 'infra/library/libraryRepo';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IQueryInfos } from '_types/queryInfos';
+import { IAttribute } from '../../../_types/attribute';
+import { IRecordFilterLight } from '../../../_types/record';
+interface IDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.infra.library': ILibraryRepo;
+    'core.infra.tree': ITreeRepo;
+}
+export interface IGetAttributesFromFieldsHelper {
+    getAttributesFromField: (field: string, ctx: IQueryInfos) => Promise<IAttribute[]>;
+}
+/**
+ * Return attributes to use in search from field sent by client.
+ * This field is a string made of different parts, concatenate with a dot.
+ * Example: created_by.login => will return the attribute created_by and login
+ *
+ * @param field
+ * @param ctx
+ */
+declare const getAttributesFromField: (params: {
+    field: string;
+    condition: IRecordFilterLight["condition"];
+    visitedLibraries?: string[];
+    deps: IDeps;
+    ctx: IQueryInfos;
+}) => Promise<IAttribute[]>;
+export default getAttributesFromField;

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

@@ -0,0 +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/helpers/sendRecordUpdateEvent.d.ts

@@ -0,0 +1,11 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { IQueryInfos } from '_types/queryInfos';
+import { IRecord, IRecordUpdateEvent } from '_types/record';
+type RequiredOnField<T, F extends keyof T> = Required<Pick<T, F>> & Omit<T, F>;
+export declare const isRecordWithId: (record: IRecord) => record is RequiredOnField<IRecord, "id">;
+export type SendRecordUpdateEventHelper = (record: IRecord, updatedValues: IRecordUpdateEvent['updatedValues'], ctx: IQueryInfos) => void;
+interface IDeps {
+    'core.domain.eventsManager': IEventsManagerDomain;
+}
+export default function ({ 'core.domain.eventsManager': eventsManagerDomain }: IDeps): SendRecordUpdateEventHelper;
+export {};

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

@@ -0,0 +1,6 @@
+import { ILibraryDomain } from 'domain/library/libraryDomain';
+import { IQueryInfos } from '_types/queryInfos';
+declare const _default: (library: string, deps: {
+    libraryDomain: ILibraryDomain;
+}, ctx: IQueryInfos) => Promise<void>;
+export default _default;

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

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

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

@@ -0,0 +1,146 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+import { IValidateHelper } from 'domain/helpers/validate';
+import { ILibraryPermissionDomain } from 'domain/permission/libraryPermissionDomain';
+import { IValueDomain } from 'domain/value/valueDomain';
+import type { i18n } from 'i18next';
+import { ILibraryRepo } from 'infra/library/libraryRepo';
+import { IRecordRepo } from 'infra/record/recordRepo';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IValueRepo } from 'infra/value/valueRepo';
+import { IUtils } from 'utils/utils';
+import * as Config from '_types/config';
+import { IListWithCursor } from '_types/list';
+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';
+import { IAttributeDomain } from '../attribute/attributeDomain';
+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';
+import winston from 'winston';
+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>;
+    activateNewRecord(params: {
+        library: string;
+        recordId: string;
+        formId?: string;
+        ctx: IQueryInfos;
+    }): Promise<ICreateRecordResult>;
+    createRecord(params: {
+        library: string;
+        values?: ISaveValue[];
+        verifyRequiredAttributes?: boolean;
+        ctx: IQueryInfos;
+    }): Promise<ICreateRecordResult>;
+    /**
+     * Update record
+     * Must be used to update metadata (modified_at, ...) only
+     */
+    updateRecord({ library, recordData, ctx }: {
+        library: string;
+        recordData: IRecord;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+    deleteRecord({ library, id, ctx }: {
+        library: string;
+        id: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+    /**
+     * Search records
+     * Filters to apply on records selection
+     * Fields to retrieve on each records
+     */
+    find({ params, ctx }: {
+        params: IFindRecordParams;
+        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
+     */
+    getRecordFieldValue({ library, record, attributeId, options, ctx }: {
+        library: string;
+        record: IRecord;
+        attributeId: string;
+        options?: IValuesOptions;
+        ctx: IQueryInfos;
+    }): Promise<IValue[]>;
+    getRecordIdentity(record: IRecord, ctx: IQueryInfos): Promise<IRecordIdentity>;
+    deactivateRecord(record: IRecord, ctx: IQueryInfos): Promise<IRecord>;
+    activateRecord(record: IRecord, ctx: IQueryInfos): Promise<IRecord>;
+    deactivateRecordsBatch(params: {
+        libraryId: string;
+        recordsIds?: string[];
+        filters?: IRecordFilterLight[];
+        ctx: IQueryInfos;
+    }): Promise<IRecord[]>;
+    activateRecordsBatch(params: {
+        libraryId: string;
+        recordsIds?: string[];
+        filters?: IRecordFilterLight[];
+        ctx: IQueryInfos;
+    }): Promise<IRecord[]>;
+    purgeInactiveRecords(params: {
+        libraryId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord[]>;
+    purgeRecord(params: {
+        libraryId: string;
+        recordId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+}
+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.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.logger': winston.Winston;
+    '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.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.logger': logger, 'core.utils': utils, translator }: IRecordDomainDeps): IRecordDomain;

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

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

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

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

package/apps/core/src/domain/tasksManager/tasksManagerDomain.d.ts

@@ -0,0 +1,68 @@
+import { IAmqpService } from '@leav/message-broker';
+import { AwilixContainer } from 'awilix';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { IUtils } from 'utils/utils';
+import winston from 'winston';
+import * as Config from '_types/config';
+import { IQueryInfos } from '_types/queryInfos';
+import { IGetCoreEntitiesParams } from '_types/shared';
+import { ISystemTranslation } from '_types/systemTranslation';
+import { ITaskRepo } from '../../infra/task/taskRepo';
+import { IList } from '../../_types/list';
+import { ITask, ITaskCallback, ITaskCancelPayload, ITaskCreatePayload, ITaskDeletePayload, TaskStatus } from '../../_types/tasksManager';
+export interface IUpdateData {
+    status?: TaskStatus;
+    progress?: {
+        percent?: number;
+        description?: ISystemTranslation;
+    };
+    startedAt?: number;
+    completedAt?: number;
+    link?: {
+        name: string;
+        url: string;
+    };
+    workerId?: number;
+    canceledBy?: string;
+    archive?: boolean;
+    callbacks?: ITaskCallback[];
+}
+interface IGetTasksParams extends IGetCoreEntitiesParams {
+    filters?: ICoreEntityFilterOptions & {
+        status?: TaskStatus;
+        startAt?: number;
+        created_by?: string;
+        archive?: boolean;
+        completedAt?: number;
+    };
+}
+export interface ITasksManagerDomain {
+    initMaster(): Promise<NodeJS.Timer>;
+    initWorker(): Promise<void>;
+    getTasks({ params, ctx }: {
+        params: IGetTasksParams;
+        ctx: IQueryInfos;
+    }): Promise<IList<ITask>>;
+    setLink(taskId: string, link: {
+        name: string;
+        url: string;
+    }, ctx: IQueryInfos): Promise<void>;
+    updateProgress(taskId: string | null, progress: {
+        percent?: number;
+        description?: ISystemTranslation;
+    }, ctx: IQueryInfos): Promise<void>;
+    createTask(task: ITaskCreatePayload, ctx: IQueryInfos): Promise<string>;
+    cancelTask(task: ITaskCancelPayload, ctx: IQueryInfos): Promise<void>;
+    deleteTasks(tasks: ITaskDeletePayload[], ctx: IQueryInfos): Promise<void>;
+}
+export interface ITasksManagerDomainDeps {
+    config: Config.IConfig;
+    'core.infra.amqpService': IAmqpService;
+    'core.infra.task': ITaskRepo;
+    'core.depsManager': AwilixContainer;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.utils.logger': winston.Winston;
+    'core.utils': IUtils;
+}
+export default function ({ config, 'core.infra.amqpService': amqpService, 'core.infra.task': taskRepo, 'core.depsManager': depsManager, 'core.domain.eventsManager': eventsManager, 'core.utils.logger': logger, 'core.utils': utils }: ITasksManagerDomainDeps): ITasksManagerDomain;
+export {};

package/apps/core/src/domain/tasksManager/tasksManagerDomain.spec.d.ts

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

package/apps/core/src/domain/tree/helpers/elementAncestors.d.ts

@@ -0,0 +1,16 @@
+import { ITreeDomain } from 'domain/tree/treeDomain';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { ICachesService } from '../../../infra/cache/cacheService';
+interface IDeps {
+    'core.infra.tree': ITreeRepo;
+    'core.infra.cache.cacheService': ICachesService;
+}
+export interface IElementAncestorsHelper {
+    getCachedElementAncestors: ITreeDomain['getElementAncestors'];
+    clearElementAncestorsCache: (params: {
+        treeId: string;
+        ctx: any;
+    }) => Promise<void>;
+}
+export default function ({ 'core.infra.tree': treeRepo, 'core.infra.cache.cacheService': cacheService }: IDeps): IElementAncestorsHelper;
+export {};

package/apps/core/src/domain/tree/helpers/getDefaultElement.d.ts

@@ -0,0 +1,22 @@
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IUtils } from 'utils/utils';
+import { ITreeNode } from '_types/tree';
+import { ICachesService } from '../../../infra/cache/cacheService';
+interface IDeps {
+    'core.infra.tree': ITreeRepo;
+    'core.infra.cache.cacheService': ICachesService;
+    'core.utils': IUtils;
+}
+export type GetDefaultElementFunc = (params: {
+    treeId: string;
+    ctx: any;
+}) => Promise<ITreeNode>;
+export interface IGetDefaultElementHelper {
+    getDefaultElement: GetDefaultElementFunc;
+    clearCache: (params: {
+        treeId: string;
+        ctx: any;
+    }) => Promise<void>;
+}
+export default function ({ 'core.infra.tree': treeRepo, 'core.infra.cache.cacheService': cacheService, 'core.utils': utils }: IDeps): IGetDefaultElementHelper;
+export {};

package/apps/core/src/domain/tree/helpers/getDefaultElement.spec.d.ts

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

package/apps/core/src/domain/tree/helpers/handleRemovedLibraries.d.ts

@@ -0,0 +1,9 @@
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IQueryInfos } from '_types/queryInfos';
+import { ITree } from '_types/tree';
+interface IDeps {
+    'core.infra.tree': ITreeRepo;
+}
+export type HandleRemovedLibrariesFunc = (treeDataBefore: ITree, treeDataAfter: ITree, ctx: IQueryInfos) => Promise<void>;
+export default function ({ 'core.infra.tree': treeRepo }: IDeps): HandleRemovedLibrariesFunc;
+export {};

package/apps/core/src/domain/tree/helpers/handleRemovedLibraries.spec.d.ts

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

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

@@ -0,0 +1,4 @@
+export { default as elementAncestors } from './elementAncestors';
+export { default as getDefaultElement } from './getDefaultElement';
+export { default as handleRemovedLibraries } from './handleRemovedLibraries';
+export { default as treeDataValidation } from './treeDataValidation';

package/apps/core/src/domain/tree/helpers/treeDataValidation.d.ts

@@ -0,0 +1,13 @@
+import { ILibraryRepo } from 'infra/library/libraryRepo';
+import { IUtils } from 'utils/utils';
+import { IQueryInfos } from '_types/queryInfos';
+import { ITree } from '../../../_types/tree';
+export interface ITreeDataValidationHelper {
+    validate(treeData: ITree, ctx: IQueryInfos): Promise<void>;
+}
+interface IDeps {
+    'core.infra.library': ILibraryRepo;
+    'core.utils': IUtils;
+}
+export default function ({ 'core.infra.library': libraryRepo, 'core.utils': utils }: IDeps): ITreeDataValidationHelper;
+export {};

package/apps/core/src/domain/tree/helpers/treeDataValidation.spec.d.ts

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

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

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