@aristid/leav-types 0.0.7 → 1.0.0-e073ed8e

package/apps/core/src/infra/permission/index.d.ts

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

package/apps/core/src/infra/permission/permissionRepo.d.ts

@@ -0,0 +1,35 @@
+import { IQueryInfos } from '_types/queryInfos';
+import { IPermission, IPermissionsTreeTarget, PermissionsActions, PermissionTypes } from '../../_types/permissions';
+import { IDbService } from '../db/dbService';
+import { IDbUtils } from '../db/dbUtils';
+export interface IPermissionRepo {
+    savePermission({ permData, ctx }: {
+        permData: IPermission;
+        ctx: IQueryInfos;
+    }): Promise<IPermission>;
+    getPermissions({ type, applyTo, usersGroupNodeId, permissionTreeTarget, ctx }: {
+        type: PermissionTypes;
+        applyTo: string;
+        usersGroupNodeId: string | null;
+        permissionTreeTarget?: IPermissionsTreeTarget;
+        ctx: IQueryInfos;
+    }): Promise<IPermission | null>;
+    getAllPermissionsForTree({ type, applyTo, actionKey, treeId, groupsIds, ctx }: {
+        type: PermissionTypes;
+        applyTo: string;
+        actionKey: PermissionsActions;
+        treeId: string;
+        groupsIds: string[];
+        ctx: IQueryInfos;
+    }): Promise<IPermission[]>;
+}
+export declare const PERM_COLLECTION_NAME = "core_permissions";
+export declare const USERS_GROUP_ATTRIBUTE_NAME = "user_groups";
+export declare const USERS_GROUP_LIB_NAME = "users_groups";
+export declare const USERS_GROUP_TREE_NAME = "users_groups";
+interface IDeps {
+    'core.infra.db.dbService'?: IDbService;
+    'core.infra.db.dbUtils'?: IDbUtils;
+}
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils }?: IDeps): IPermissionRepo;
+export {};

package/apps/core/src/infra/permission/permissionRepo.spec.d.ts

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

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

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

package/apps/core/src/infra/plugins/pluginsRepo.d.ts

@@ -0,0 +1,6 @@
+import { IPluginInfos, IRegisteredPlugin } from '_types/plugin';
+export interface IPluginsRepo {
+    registerPlugin(path: string, plugin: IPluginInfos): IRegisteredPlugin;
+    getRegisteredPlugins(): IRegisteredPlugin[];
+}
+export default function (): IPluginsRepo;

package/apps/core/src/infra/plugins/pluginsRepo.spec.d.ts

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

package/apps/core/src/infra/record/helpers/filterTypes.d.ts

@@ -0,0 +1,7 @@
+import { IRecordFilterOption } from '../../../_types/record';
+export interface IFilterTypesHelper {
+    isAttributeFilter(filter: IRecordFilterOption): boolean;
+    isClassifyingFilter(filter: IRecordFilterOption): boolean;
+    isCountFilter(filter: IRecordFilterOption): boolean;
+}
+export default function (): IFilterTypesHelper;

package/apps/core/src/infra/record/helpers/filterTypes.spec.d.ts

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

package/apps/core/src/infra/record/helpers/getClassifyingFiltersVariableQueryPart.d.ts

@@ -0,0 +1,11 @@
+import { GeneratedAqlQuery } from 'arangojs/aql';
+import { IDbService } from 'infra/db/dbService';
+import { IRecordFilterOption } from '_types/record';
+import { IFilterTypesHelper } from './filterTypes';
+interface IDeps {
+    'core.infra.db.dbService'?: IDbService;
+    'core.infra.record.helpers.filterTypes'?: IFilterTypesHelper;
+}
+export type GetClassifyingFiltersVariableQueryPart = (filter: IRecordFilterOption) => GeneratedAqlQuery;
+export default function ({ 'core.infra.record.helpers.filterTypes': filterTypesHelper, 'core.infra.db.dbService': dbService }: IDeps): GetClassifyingFiltersVariableQueryPart;
+export {};

package/apps/core/src/infra/record/helpers/getClassifyingFiltersVariableQueryPart.spec.d.ts

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

package/apps/core/src/infra/record/helpers/getSearchVariableName.d.ts

@@ -0,0 +1,8 @@
+import { IRecordFilterOption } from '../../../_types/record';
+import { IFilterTypesHelper } from './filterTypes';
+interface IDeps {
+    'core.infra.record.helpers.filterTypes'?: IFilterTypesHelper;
+}
+export type GetSearchVariableName = (filter: IRecordFilterOption) => string | undefined;
+export default function ({ 'core.infra.record.helpers.filterTypes': filterTypesHelper }: IDeps): GetSearchVariableName;
+export {};

package/apps/core/src/infra/record/helpers/getSearchVariableName.spec.d.ts

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

package/apps/core/src/infra/record/helpers/getSearchVariablesQueryPart.d.ts

@@ -0,0 +1,15 @@
+import { GeneratedAqlQuery } from 'arangojs/aql';
+import { IAttributeTypesRepo } from 'infra/attributeTypes/attributeTypesRepo';
+import { IRecordFilterOption } from '../../../_types/record';
+import { IFilterTypesHelper } from './filterTypes';
+import { GetClassifyingFiltersVariableQueryPart } from './getClassifyingFiltersVariableQueryPart';
+import { GetSearchVariableName } from './getSearchVariableName';
+interface IDeps {
+    'core.infra.attributeTypes'?: IAttributeTypesRepo;
+    'core.infra.record.helpers.getClassifyingFiltersVariableQueryPart'?: GetClassifyingFiltersVariableQueryPart;
+    'core.infra.record.helpers.getSearchVariableName'?: GetSearchVariableName;
+    'core.infra.record.helpers.filterTypes'?: IFilterTypesHelper;
+}
+export type GetSearchVariablesQueryPart = (filters: IRecordFilterOption[]) => GeneratedAqlQuery[];
+export default function ({ 'core.infra.attributeTypes': attributeTypes, 'core.infra.record.helpers.getClassifyingFiltersVariableQueryPart': getClassifyingFiltersVariableQueryPart, 'core.infra.record.helpers.getSearchVariableName': getSearchVariableName, 'core.infra.record.helpers.filterTypes': filterTypesHelper }: IDeps): GetSearchVariablesQueryPart;
+export {};

package/apps/core/src/infra/record/helpers/getSearchVariablesQueryPart.spec.d.ts

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

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

@@ -0,0 +1,4 @@
+export { default as filterTypes } from './filterTypes';
+export { default as getClassifyingFiltersVariableQueryPart } from './getClassifyingFiltersVariableQueryPart';
+export { default as getSearchVariableName } from './getSearchVariableName';
+export { default as getSearchVariablesQueryPart } from './getSearchVariablesQueryPart';

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

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

package/apps/core/src/infra/record/recordRepo.d.ts

@@ -0,0 +1,71 @@
+import { GeneratedAqlQuery } from 'arangojs/aql';
+import { GetConditionPart } from 'infra/attributeTypes/helpers/getConditionPart';
+import { GetSearchQuery } from 'infra/indexation/helpers/getSearchQuery';
+import { IQueryInfos } from '_types/queryInfos';
+import { ICursorPaginationParams, IListWithCursor, IPaginationParams } from '../../_types/list';
+import { IRecord, IRecordFilterOption, IRecordSort } from '../../_types/record';
+import { IAttributeRepo } from '../attribute/attributeRepo';
+import { IAttributeTypesRepo } from '../attributeTypes/attributeTypesRepo';
+import { IDbService } from '../db/dbService';
+import { IDbUtils } from '../db/dbUtils';
+import { IFilterTypesHelper } from './helpers/filterTypes';
+import { GetSearchVariableName } from './helpers/getSearchVariableName';
+import { GetSearchVariablesQueryPart } from './helpers/getSearchVariablesQueryPart';
+import { IGetAccessPermissionsValue } from 'domain/record/helpers/getAccessPermissionFilters';
+export interface IFindRequestResult {
+    initialVars: GeneratedAqlQuery[];
+    queryPart: GeneratedAqlQuery;
+}
+export interface IRecordRepo {
+    createRecord({ libraryId, recordData, ctx }: {
+        libraryId: string;
+        recordData: IRecord;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+    updateRecord({ libraryId, recordData, ctx }: {
+        libraryId: string;
+        recordData: IRecord;
+        mergeObjects?: boolean;
+        ctx: IQueryInfos;
+    }): Promise<{
+        old: IRecord;
+        new: IRecord;
+    }>;
+    deleteRecord({ libraryId, recordId, ctx }: {
+        libraryId: string;
+        recordId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+    find(params: {
+        libraryId: string;
+        filters?: IRecordFilterOption[];
+        sort?: IRecordSort[];
+        pagination?: IPaginationParams | ICursorPaginationParams;
+        withCount?: boolean;
+        retrieveInactive?: boolean;
+        fulltextSearch?: string;
+        ctx: IQueryInfos;
+        accessPermissionFilters?: IGetAccessPermissionsValue[];
+    }): Promise<IListWithCursor<IRecord>>;
+    /**
+     * get record by recordId, return null if record not found
+     * NB: use internal dataloader to mutualize query when possible for a given ctx
+     */
+    getRecord(params: {
+        libraryId: string;
+        recordId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord | null>;
+}
+export interface IRecordRepoDeps {
+    'core.infra.db.dbService': IDbService;
+    'core.infra.db.dbUtils': IDbUtils;
+    'core.infra.attributeTypes': IAttributeTypesRepo;
+    'core.infra.attribute': IAttributeRepo;
+    'core.infra.attributeTypes.helpers.getConditionPart': GetConditionPart;
+    'core.infra.record.helpers.getSearchVariablesQueryPart': GetSearchVariablesQueryPart;
+    'core.infra.record.helpers.getSearchVariableName': GetSearchVariableName;
+    'core.infra.record.helpers.filterTypes': IFilterTypesHelper;
+    'core.infra.indexation.helpers.getSearchQuery': GetSearchQuery;
+}
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.infra.attributeTypes': attributeTypesRepo, 'core.infra.attributeTypes.helpers.getConditionPart': getConditionPart, 'core.infra.record.helpers.getSearchVariablesQueryPart': getSearchVariablesQueryPart, 'core.infra.record.helpers.getSearchVariableName': getSearchVariableName, 'core.infra.record.helpers.filterTypes': filterTypesHelper, 'core.infra.indexation.helpers.getSearchQuery': getSearchQuery, 'core.infra.attribute': attributeRepo }: IRecordRepoDeps): IRecordRepo;

package/apps/core/src/infra/record/recordRepo.spec.d.ts

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

package/apps/core/src/infra/task/index.d.ts

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

package/apps/core/src/infra/task/taskRepo.d.ts

@@ -0,0 +1,30 @@
+import { IDbService } from 'infra/db/dbService';
+import { IDbUtils } from 'infra/db/dbUtils';
+import { IList } from '_types/list';
+import { IQueryInfos } from '_types/queryInfos';
+import { IGetCoreEntitiesParams } from '_types/shared';
+import { ITask } from '../../_types/tasksManager';
+import { IUtils } from 'utils/utils';
+export declare const TASKS_COLLECTION = "core_tasks";
+export interface ITaskRepo {
+    getTasks({ params, ctx }: {
+        params?: IGetCoreEntitiesParams;
+        ctx: IQueryInfos;
+    }): Promise<IList<ITask>>;
+    createTask(task: Omit<ITask, 'created_at' | 'created_by' | 'modified_at'>, ctx: IQueryInfos): Promise<ITask>;
+    updateTask(task: Partial<ITask> & {
+        id: string;
+    }, ctx: IQueryInfos): Promise<ITask>;
+    getTasksToExecute(ctx: IQueryInfos): Promise<IList<ITask>>;
+    getTasksToCancel(ctx: IQueryInfos): Promise<IList<ITask>>;
+    getTasksWithPendingCallbacks(ctx: IQueryInfos): Promise<IList<ITask>>;
+    deleteTask(taskId: any, ctx: any): Promise<ITask>;
+    isATaskRunning(ctx: IQueryInfos, workerId?: number): Promise<boolean>;
+}
+interface IDeps {
+    'core.infra.db.dbUtils'?: IDbUtils;
+    'core.infra.db.dbService'?: IDbService;
+    'core.utils'?: IUtils;
+}
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils, 'core.utils': utils }?: IDeps): ITaskRepo;
+export {};

package/apps/core/src/infra/task/taskRepo.spec.d.ts

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

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

@@ -0,0 +1,9 @@
+import { IDbDocument } from 'infra/db/_types';
+export interface IChildrenResultNode {
+    id: string;
+    record: IDbDocument;
+    order: number;
+    childrenCount?: number;
+}
+export declare const NODE_LIBRARY_ID_FIELD = "libraryId";
+export declare const NODE_RECORD_ID_FIELD = "recordId";

package/apps/core/src/infra/tree/helpers/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const getNodesCollectionName: (treeId: string) => string;
+export declare const getEdgesCollectionName: (treeId: string) => string;
+export declare const getRootId: (treeId: string) => string;
+export declare const getFullNodeId: (nodeId: string, treeId: string) => string;
+export declare const getLibraryFromDbId: (dbId: string) => string;

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

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

package/apps/core/src/infra/tree/treeRepo.d.ts

@@ -0,0 +1,169 @@
+import { IList, IPaginationParams } from '_types/list';
+import { IQueryInfos } from '_types/queryInfos';
+import { IRecord } from '_types/record';
+import { IGetCoreTreesParams, ITree, ITreeElement, ITreeNode, ITreeNodeLight, TreePath } from '_types/tree';
+import { IDbService } from '../db/dbService';
+import { IDbUtils } from '../db/dbUtils';
+export interface ITreeRepo {
+    createTree(params: {
+        treeData: ITree;
+        ctx: IQueryInfos;
+    }): Promise<ITree>;
+    updateTree(params: {
+        treeData: ITree;
+        ctx: IQueryInfos;
+    }): Promise<ITree>;
+    getTrees(params: {
+        params?: IGetCoreTreesParams;
+        ctx: IQueryInfos;
+    }): Promise<IList<ITree>>;
+    deleteTree(params: {
+        id: string;
+        ctx: IQueryInfos;
+    }): Promise<ITree>;
+    /**
+     * Add an element to the tree
+     *
+     * Parent must be a record or null to add element to root
+     *
+     * We return a TreeNodeLight and not a TreeNode to avoid an extra query just to get the record. If client needs it,
+     * we'll get it through or manually where needed
+     */
+    addElement(params: {
+        treeId: string;
+        element: ITreeElement;
+        parent: string | null;
+        order?: number;
+        ctx: IQueryInfos;
+    }): Promise<ITreeNodeLight>;
+    /**
+     * Move an element in the tree
+     *
+     * parentTo A record or null to move to root
+     *
+     * We return a TreeNodeLight and not a TreeNode to avoid an extra query just to get the record. If client needs it,
+     * we'll get it through or manually where needed
+     */
+    moveElement(params: {
+        treeId: string;
+        nodeId: string;
+        parentTo: string | null;
+        order?: number;
+        ctx: IQueryInfos;
+    }): Promise<ITreeNodeLight>;
+    /**
+     * Delete an element from the tree
+     *
+     * We return a TreeNodeLight and not a TreeNode to avoid an extra query just to get the record. If client needs it,
+     * we'll get it through or manually where needed
+     */
+    deleteElement(params: {
+        treeId: string;
+        nodeId: string;
+        deleteChildren: boolean | null;
+        ctx: IQueryInfos;
+    }): Promise<ITreeNodeLight>;
+    /**
+     * Return whether a node is present in given tree
+     */
+    isNodePresent(params: {
+        treeId: string;
+        nodeId: string;
+        ctx: IQueryInfos;
+    }): Promise<boolean>;
+    /**
+     * Return whether a record is present in given tree
+     */
+    isRecordPresent(params: {
+        treeId: string;
+        record: ITreeElement;
+        ctx: IQueryInfos;
+    }): Promise<boolean>;
+    /**
+     * Return the whole tree in the form:
+     * [
+     *      {
+     *          record: {...},
+     *          children: [
+     *              {
+     *                  record: ...
+     *                  children: ...
+     *              }
+     *          ]
+     *      },
+     *      { ... }
+     * ]
+     *
+     * startingNode  Return the tree starting from this node. If not specified, start from root
+     */
+    getTreeContent(params: {
+        treeId: string;
+        startingNode?: string;
+        depth?: number;
+        childrenCount?: boolean;
+        ctx: IQueryInfos;
+    }): Promise<ITreeNode[]>;
+    /**
+     * Return all first level children of an element
+     */
+    getElementChildren(params: {
+        treeId: string;
+        nodeId: string;
+        childrenCount?: boolean;
+        withTotalCount?: boolean;
+        pagination?: IPaginationParams;
+        ctx: IQueryInfos;
+    }): Promise<IList<ITreeNode>>;
+    /**
+     * Return all ancestors of an element, from root to element, but excluding tree root
+     * Prefer use core.domain.tree.helpers.elementAncestors.getCachedElementAncestors
+     *
+     * @param treeId
+     * @param element
+     */
+    getElementAncestors(params: {
+        treeId: string;
+        nodeId: string;
+        ctx: IQueryInfos;
+    }): Promise<TreePath>;
+    getLinkedRecords(params: {
+        treeId: string;
+        attribute: string;
+        nodeId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord[]>;
+    /**
+     * Return record linked to given node
+     */
+    getRecordByNodeId(params: {
+        treeId: string;
+        nodeId: string;
+        ctx: IQueryInfos;
+    }): Promise<IRecord>;
+    /**
+     * Return nodes linked to given record
+     */
+    getNodesByRecord(params: {
+        treeId: string;
+        record: ITreeElement;
+        ctx: IQueryInfos;
+    }): Promise<string[]>;
+    /**
+     * Return all nodes for given library
+     */
+    getNodesByLibrary(params: {
+        treeId: string;
+        libraryId: string;
+        ctx: IQueryInfos;
+    }): Promise<string[]>;
+}
+export declare const TREES_COLLECTION_NAME = "core_trees";
+export declare const NODE_COLLEC_PREFIX = "core_nodes_";
+export declare const EDGE_COLLEC_PREFIX = "core_edge_tree_";
+export declare const MAX_TREE_DEPTH = 1000;
+export declare const TO_RECORD_PROP_NAME = "toRecord";
+export interface ITreeRepoDeps {
+    'core.infra.db.dbService': IDbService;
+    'core.infra.db.dbUtils': IDbUtils;
+}
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils }: ITreeRepoDeps): ITreeRepo;

package/apps/core/src/infra/tree/treeRepo.spec.d.ts

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

package/apps/core/src/infra/userData/index.d.ts

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

package/apps/core/src/infra/userData/userDataRepo.d.ts

@@ -0,0 +1,19 @@
+import { IQueryInfos } from '_types/queryInfos';
+import { IUserData } from '_types/userData';
+import { IDbService } from '../db/dbService';
+interface ISaveUserDataParams {
+    key: string;
+    value: any;
+    global: boolean;
+    isCoreData?: boolean;
+    ctx: IQueryInfos;
+}
+export interface IUserDataRepo {
+    saveUserData(params: ISaveUserDataParams): Promise<IUserData>;
+    getUserData(keys: string[], global: boolean, ctx: IQueryInfos): Promise<IUserData>;
+}
+export interface IUserDataRepoDeps {
+    'core.infra.db.dbService': IDbService;
+}
+export default function ({ 'core.infra.db.dbService': dbService }: IUserDataRepoDeps): IUserDataRepo;
+export {};

package/apps/core/src/infra/userData/userDataRepo.spec.d.ts

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

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

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

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

@@ -0,0 +1,90 @@
+import { IDbService } from 'infra/db/dbService';
+import { IConfig } from '_types/config';
+import { IAttribute } from '_types/attribute';
+import { IQueryInfos } from '_types/queryInfos';
+import { ISaveValue, IValue } from '_types/value';
+import { IAttributeTypesRepo, IAttributeWithRevLink, IGetValuesOptions } from '../attributeTypes/attributeTypesRepo';
+export declare const VALUES_LINKS_COLLECTION = "core_edge_values_links";
+export declare const VALUES_COLLECTION = "core_values";
+export declare const EMPTY_VALUE = "__empty_value__";
+export interface IValueRepo {
+    createValue({ library, recordId, attribute, value, ctx }: {
+        library: string;
+        recordId: string;
+        attribute: IAttributeWithRevLink;
+        value: ISaveValue;
+        ctx: IQueryInfos;
+    }): Promise<IValue>;
+    /**
+     * Update an existing value. Field "id" is expected on the value
+     */
+    updateValue({ library, recordId, attribute, value, ctx }: {
+        library: string;
+        recordId: string;
+        attribute: IAttributeWithRevLink;
+        value: ISaveValue;
+        ctx: IQueryInfos;
+    }): Promise<IValue>;
+    /**
+     * Delete an existing value. Field "id" is expected on the value
+     */
+    deleteValue({ library, recordId, attribute, value, ctx }: {
+        library: string;
+        recordId: string;
+        attribute: IAttributeWithRevLink;
+        value: IValue;
+        ctx: IQueryInfos;
+    }): Promise<IValue>;
+    /**
+     * Check if a value is unique expeted for the given record
+     * if recordId is null, it will check for the whole library
+     */
+    isValueUsed({ library, excludedRecordId, attribute, value, ctx }: {
+        library: string;
+        excludedRecordId?: string;
+        attribute: IAttribute;
+        value: IValue;
+        ctx: IQueryInfos;
+    }): Promise<boolean>;
+    /**
+     * Get all values for given record and attribute
+     *
+     * @return Array<{}>    Return an empty array if no value found
+     */
+    getValues({ library, recordId, attribute, forceGetAllValues, options, ctx }: {
+        library: string;
+        recordId: string;
+        attribute: IAttributeWithRevLink;
+        forceGetAllValues?: boolean;
+        options?: IGetValuesOptions;
+        ctx: IQueryInfos;
+    }): Promise<IValue[]>;
+    /**
+     * Return a specific value based on its ID. Field "id" is expect on the value
+     *
+     * @return {}   Return null if no value found
+     */
+    getValueById({ library, recordId, attribute, valueId, ctx }: {
+        library: string;
+        recordId: string;
+        attribute: IAttribute;
+        valueId: string;
+        ctx: IQueryInfos;
+    }): Promise<IValue>;
+    clearAllValues({ attribute, ctx }: {
+        attribute: IAttribute;
+        ctx: IQueryInfos;
+    }): Promise<boolean>;
+    deleteAllValuesByRecord(params: {
+        libraryId: string;
+        recordId: string;
+        ctx: IQueryInfos;
+    }): Promise<void>;
+}
+interface IDeps {
+    config?: IConfig;
+    'core.infra.attributeTypes': IAttributeTypesRepo;
+    'core.infra.db.dbService': IDbService;
+}
+export default function ({ config, 'core.infra.attributeTypes': attributeTypesRepo, 'core.infra.db.dbService': dbService }: IDeps): IValueRepo;
+export {};

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

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

package/apps/core/src/infra/versionProfile/index.d.ts

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

package/apps/core/src/infra/versionProfile/versionProfileRepo.d.ts

@@ -0,0 +1,35 @@
+import { IDbService } from 'infra/db/dbService';
+import { IDbUtils } from 'infra/db/dbUtils';
+import { IAttribute } from '_types/attribute';
+import { IList } from '_types/list';
+import { IQueryInfos } from '_types/queryInfos';
+import { IGetCoreVersionProfileParams, IVersionProfile } from '_types/versionProfile';
+export declare const VERSION_PROFILE_COLLECTION_NAME = "core_version_profiles";
+export interface IVersionProfileRepo {
+    getVersionProfiles: (params: {
+        params?: IGetCoreVersionProfileParams;
+        ctx: IQueryInfos;
+    }) => Promise<IList<IVersionProfile>>;
+    createVersionProfile: (params: {
+        profileData: IVersionProfile;
+        ctx: IQueryInfos;
+    }) => Promise<IVersionProfile>;
+    updateVersionProfile: (params: {
+        profileData: IVersionProfile;
+        ctx: IQueryInfos;
+    }) => Promise<IVersionProfile>;
+    deleteVersionProfile: (params: {
+        id: string;
+        ctx: IQueryInfos;
+    }) => Promise<IVersionProfile>;
+    getAttributesUsingProfile(params: {
+        id: string;
+        ctx: IQueryInfos;
+    }): Promise<IAttribute[]>;
+}
+interface IDeps {
+    'core.infra.db.dbUtils'?: IDbUtils;
+    'core.infra.db.dbService'?: IDbService;
+}
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils }?: IDeps): IVersionProfileRepo;
+export {};

package/apps/core/src/infra/versionProfile/versionProfileRepo.spec.d.ts

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

package/apps/core/src/infra/view/_types.d.ts

@@ -0,0 +1,17 @@
+import { IDbService } from 'infra/db/dbService';
+import { IDbUtils } from 'infra/db/dbUtils';
+import { IList } from '_types/list';
+import { IGetCoreEntitiesParams } from '_types/shared';
+import { IQueryInfos } from '../../_types/queryInfos';
+import { IView } from '_types/views';
+export declare const VIEWS_COLLECTION_NAME = "core_views";
+export interface IViewRepo {
+    createView(view: IView, ctx: IQueryInfos): Promise<IView>;
+    updateView(view: IView, ctx: IQueryInfos): Promise<IView>;
+    getViews(params: IGetCoreEntitiesParams, ctx: IQueryInfos): Promise<IList<IView>>;
+    deleteView(viewId: string, ctx: IQueryInfos): Promise<IView>;
+}
+export interface IViewRepoDeps {
+    'core.infra.db.dbService': IDbService;
+    'core.infra.db.dbUtils': IDbUtils;
+}

package/apps/core/src/infra/view/index.d.ts

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

package/apps/core/src/infra/view/viewRepo.d.ts

@@ -0,0 +1,2 @@
+import { IViewRepo, IViewRepoDeps } from './_types';
+export default function ({ 'core.infra.db.dbService': dbService, 'core.infra.db.dbUtils': dbUtils }: IViewRepoDeps): IViewRepo;

package/apps/core/src/infra/view/viewRepo.spec.d.ts

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

package/apps/core/src/interface/cli.d.ts

@@ -0,0 +1,8 @@
+import { ICoreImportApp } from 'app/core/importApp';
+interface IDeps {
+    'core.app.core.import': ICoreImportApp;
+}
+export default function ({ 'core.app.core.import': importApp }: IDeps): {
+    run(): void;
+};
+export {};

package/apps/core/src/interface/filesManager.d.ts

@@ -0,0 +1,9 @@
+import { IFilesManagerApp } from 'app/core/filesManagerApp';
+export interface IFilesManagerInterface {
+    init(): Promise<void>;
+}
+interface IDeps {
+    'core.app.core.filesManager': IFilesManagerApp;
+}
+export default function ({ 'core.app.core.filesManager': filesManager }: IDeps): IFilesManagerInterface;
+export {};