@aristid/leav-types 0.0.2 → 0.0.4-b0a5cfe

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

@@ -0,0 +1,3 @@
+export interface ISystemTranslation {
+    [lang: string]: string;
+}

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

@@ -0,0 +1,97 @@
+import { ISystemTranslation } from './systemTranslation';
+export declare enum OrderType {
+    CREATE = "CREATE",
+    CANCEL = "CANCEL",
+    DELETE = "DELETE"
+}
+export declare enum TaskStatus {
+    CREATED = "CREATED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    FAILED = "FAILED",
+    DONE = "DONE",
+    PENDING_CANCEL = "PENDING_CANCEL",
+    CANCELED = "CANCELED"
+}
+export declare enum TaskPriority {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2
+}
+export type ITaskCreatePayload = Pick<ITask, 'label' | 'func' | 'priority' | 'callbacks'> & Partial<Pick<ITask, 'id' | 'startAt' | 'role'>>;
+export type ITaskCancelPayload = Pick<ITask, 'id'>;
+export type ITaskDeletePayload = Pick<ITask, 'id'> & {
+    archive: boolean;
+};
+export type Payload = ITaskCreatePayload | ITaskCancelPayload | ITaskDeletePayload;
+export interface ITaskOrder {
+    time: number;
+    userId: string;
+    payload: Payload;
+}
+export interface ITaskFunc {
+    moduleName: string;
+    subModuleName?: string;
+    name: string;
+    args: {
+        [key: string]: any;
+    };
+}
+export declare enum TaskCallbackType {
+    ON_SUCCESS = "ON_SUCCESS",
+    ON_FAILURE = "ON_FAILURE",
+    ON_CANCEL = "ON_CANCEL"
+}
+export declare enum TaskCallbackStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    FAILED = "FAILED",
+    DONE = "DONE",
+    SKIPPED = "SKIPPED"
+}
+export type ITaskCallback = ITaskFunc & {
+    args: any[];
+    type: TaskCallbackType[];
+    status?: TaskCallbackStatus;
+};
+export interface ITaskFuncParams {
+    id?: string;
+    startAt?: number;
+    callbacks?: ITaskCallback[];
+}
+export declare enum TaskType {
+    EXPORT = "EXPORT",
+    IMPORT_CONFIG = "IMPORT_CONFIG",
+    IMPORT_DATA = "IMPORT_DATA",
+    INDEXATION = "INDEXATION"
+}
+export interface ITaskRole {
+    type: TaskType;
+    detail?: string;
+}
+export interface ITask {
+    id: string;
+    label: ISystemTranslation;
+    created_at: number;
+    created_by: string;
+    modified_at: number;
+    func: ITaskFunc;
+    startAt: number;
+    status: TaskStatus;
+    priority: TaskPriority;
+    archive: boolean;
+    role?: ITaskRole;
+    canceledBy?: string;
+    progress?: {
+        percent?: number;
+        description?: ISystemTranslation;
+    };
+    startedAt?: number;
+    completedAt?: number;
+    link?: {
+        name: string;
+        url: string;
+    };
+    callbacks?: ITaskCallback[];
+    workerId?: number;
+}

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

@@ -0,0 +1,63 @@
+import { ITreeNodePermissionsConf } from './permissions';
+import { IRecord } from './record';
+import { IGetCoreEntitiesParams, IKeyValue } from './shared';
+export interface ITreeLibrarySettings {
+    allowMultiplePositions: boolean;
+    allowedChildren: string[];
+    allowedAtRoot: boolean;
+}
+export interface ITree extends ICoreEntity {
+    libraries: IKeyValue<ITreeLibrarySettings>;
+    behavior?: TreeBehavior;
+    system?: boolean;
+    permissions_conf?: ITreeNodePermissionsConf;
+}
+export interface ITreeFilterOptions extends ICoreEntityFilterOptions {
+    system?: boolean;
+    library?: string;
+}
+export interface IGetCoreTreesParams extends IGetCoreEntitiesParams {
+    filters?: ITreeFilterOptions;
+}
+export interface ITreeElement {
+    id: string;
+    library: string;
+}
+export interface ITreeNode {
+    id: string;
+    order?: number;
+    childrenCount?: number;
+    record?: IRecord;
+    parent?: ITreeNode[];
+    ancestors?: ITreeNode[];
+    children?: ITreeNode[];
+    linkedRecords?: IRecord[];
+}
+export type ITreeNodeLight = Pick<ITreeNode, 'id' | 'order'>;
+export interface ITreeNodeWithTreeId extends ITreeNode {
+    treeId: string;
+}
+export type TreePaths = ITreeNode[];
+export declare enum TreeBehavior {
+    STANDARD = "standard",
+    FILES = "files"
+}
+export declare enum TreeEventTypes {
+    ADD = "add",
+    REMOVE = "remove",
+    MOVE = "move"
+}
+export interface ITreeEvent {
+    type: TreeEventTypes;
+    treeId: string;
+    element: ITreeNodeLight & {
+        treeId: string;
+    };
+    parentNode?: ITreeNodeLight & {
+        treeId: string;
+    };
+    parentNodeBefore?: ITreeNodeLight & {
+        treeId: string;
+    };
+    order: number;
+}

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

@@ -0,0 +1,4 @@
+export interface IUserData {
+    global: boolean;
+    data: any;
+}

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

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

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

@@ -0,0 +1,78 @@
+import { AnyPrimitive, Override } from '@leav/utils';
+import { IDbEdge } from 'infra/db/_types';
+import { IRecord } from './record';
+import { ITreeNode, TreePaths } from './tree';
+export type IValueFromGql = Override<Omit<IValue, 'version'>, {
+    value: IValue['payload'];
+    metadata: Array<{
+        name: string;
+        value: string;
+    }>;
+}>;
+export interface IValueVersion {
+    [treeName: string]: string;
+}
+export type IValueVersionFromGql = Array<{
+    treeId: string;
+    treeNodeId: string;
+}>;
+export type IValueFromGraphql = Override<IValue, {
+    metadata: Array<{
+        name: string;
+        value: string;
+    }>;
+}>;
+export interface IDbValueVersion {
+    [treeName: string]: string;
+}
+export interface IValueMetadata {
+    [fieldName: string]: IStandardValue | AnyPrimitive;
+}
+export interface IGenericValue {
+    id_value?: string;
+    attribute?: string;
+    created_at?: number;
+    modified_at?: number;
+    created_by?: string;
+    modified_by?: string;
+    version?: IValueVersion;
+    metadata?: IValueMetadata;
+    isInherited?: boolean;
+    isCalculated?: boolean;
+}
+export interface IStandardValue extends IGenericValue {
+    payload?: any;
+    raw_payload?: any;
+}
+export interface ILinkValue extends IGenericValue {
+    payload?: IRecord;
+}
+export interface ITreeValue extends IGenericValue {
+    payload?: ITreeNode;
+    treeId: string;
+}
+export type IValue = IStandardValue | ILinkValue | ITreeValue;
+export interface IDateRangeValue<T = string | number> {
+    from: T;
+    to: T;
+}
+export interface IValuesOptions {
+    version?: IValueVersion;
+    forceArray?: boolean;
+    forceGetAllValues?: boolean;
+    [optionName: string]: any;
+}
+export interface IFindValueTree {
+    name: string;
+    currentIndex: number;
+    elements: TreePaths;
+}
+export interface IValueEdge extends IDbEdge {
+    attribute: string;
+    modified_at: number;
+    modified_by: string;
+    created_at: number;
+    created_by: string;
+    version?: IDbValueVersion;
+    metadata?: IValueMetadata;
+}

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

@@ -0,0 +1,17 @@
+import { IGetCoreEntitiesParams } from './shared';
+import { ISystemTranslation } from './systemTranslation';
+export interface IVersionProfile {
+    id: string;
+    label: ISystemTranslation;
+    description?: ISystemTranslation;
+    trees: string[];
+}
+/**
+ * Accepted fields to filter version profiles list
+ */
+export interface IVersionProfileFilterOptions extends ICoreEntityFilterOptions {
+    trees?: string;
+}
+export interface IGetCoreVersionProfileParams extends IGetCoreEntitiesParams {
+    filters?: IVersionProfileFilterOptions;
+}

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

@@ -0,0 +1,57 @@
+import { IRecordFilterLight, IRecordSortLight } from './record';
+import { ISystemTranslation } from './systemTranslation';
+export declare enum ViewTypes {
+    LIST = "list",
+    CARDS = "cards",
+    TIMELINE = "timeline"
+}
+export declare enum ViewSizes {
+    SMALL = "SMALL",
+    MEDIUM = "MEDIUM",
+    BIG = "BIG"
+}
+declare global {
+    interface IView extends ICoreEntity {
+        shared?: boolean;
+        created_by?: string;
+        created_at?: number;
+        modified_at?: number;
+        library?: string;
+        description?: ISystemTranslation;
+        color?: string;
+        display?: IViewDisplay;
+        filters?: IRecordFilterLight[];
+        sort?: IRecordSortLight;
+        valuesVersions?: IViewValuesVersion;
+        settings: IViewSettings;
+    }
+    interface IViewDisplay {
+        type: ViewTypes;
+        size: ViewSizes;
+    }
+    interface IViewSettingsNameVal {
+        name: string;
+        value: unknown;
+    }
+    type ViewFromGraphQL = Omit<IView, 'valuesVersions' | 'settings'> & {
+        valuesVersions: IViewValuesVersionForGraphql[];
+        settings: IViewSettingsNameVal[];
+    };
+    interface IViewSettings {
+        [key: string]: unknown;
+    }
+    interface IViewFilterOptions extends ICoreEntityFilterOptions {
+        created_by?: string;
+        library?: string;
+        type?: ViewTypes;
+    }
+    interface IViewValuesVersion {
+        [treeId: string]: string;
+    }
+    interface IViewValuesVersionForGraphql {
+        treeId: string;
+        treeNode: {
+            id: string;
+        };
+    }
+}

package/apps/core/src/app/application/__tests__/applicationApp.spec.d.ts

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

package/apps/core/src/app/application/applicationApp.d.ts

@@ -0,0 +1,32 @@
+import { ICoreSubscriptionsHelpersApp } from 'app/core/helpers/subscriptions';
+import { IGraphqlApp } from 'app/graphql/graphqlApp';
+import { InitQueryContextFunc } from 'app/helpers/initQueryContext';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { IPermissionDomain } from 'domain/permission/permissionDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { Express } from 'express';
+import { IUtils } from 'utils/utils';
+import winston from 'winston';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IApplicationDomain } from '../../domain/application/applicationDomain';
+import { ValidateRequestTokenFunc } from '../helpers/validateRequestToken';
+import { IAuthApp } from '../auth/authApp';
+export interface IApplicationApp {
+    registerRoute(app: Express): void;
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+}
+export interface IApplicationAppDeps {
+    'core.app.graphql': IGraphqlApp;
+    'core.app.auth': IAuthApp;
+    'core.app.helpers.initQueryContext': InitQueryContextFunc;
+    'core.app.helpers.validateRequestToken': ValidateRequestTokenFunc;
+    'core.app.core.subscriptionsHelper': ICoreSubscriptionsHelpersApp;
+    'core.domain.application': IApplicationDomain;
+    'core.domain.permission': IPermissionDomain;
+    'core.domain.record': IRecordDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.utils.logger': winston.Winston;
+    'core.utils': IUtils;
+    config: any;
+}
+export default function ({ 'core.app.graphql': graphqlApp, 'core.app.auth': authApp, 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.validateRequestToken': validateRequestToken, 'core.app.core.subscriptionsHelper': subscriptionsHelper, 'core.domain.application': applicationDomain, 'core.domain.permission': permissionDomain, 'core.domain.record': recordDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.utils.logger': logger, 'core.utils': utils, config }: IApplicationAppDeps): IApplicationApp;

package/apps/core/src/app/application/index.d.ts

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

package/apps/core/src/app/auth/__tests__/authApp.spec.d.ts

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

package/apps/core/src/app/auth/authApp.d.ts

@@ -0,0 +1,38 @@
+import { IApiKeyDomain } from 'domain/apiKey/apiKeyDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { IUserDomain } from 'domain/user/userDomain';
+import { IValueDomain } from 'domain/value/valueDomain';
+import { Express, Response } from 'express';
+import { IConfig } from '_types/config';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { ICachesService } from '../../infra/cache/cacheService';
+import { ITokenUserData } from '../../_types/auth';
+import { IRequestWithContext } from '../../_types/express';
+import winston from 'winston';
+import { IOIDCClientService } from '../../infra/oidc/oidcClientService';
+import { InitQueryContextFunc } from '../helpers/initQueryContext';
+import { IConvertOIDCIdentifier } from '../helpers/convertOIDCIdentifier';
+import { IncomingHttpHeaders } from 'http';
+export interface IAuthApp {
+    getGraphQLSchema(): IAppGraphQLSchema;
+    validateRequestToken(params: {
+        apiKey?: string;
+        headers: IncomingHttpHeaders;
+        cookies?: {};
+    }, res: Response<unknown>): Promise<ITokenUserData>;
+    registerRoute(app: Express): void;
+    authenticateWithOIDCService(req: IRequestWithContext, res: Response<unknown>): Promise<void | Response>;
+}
+export interface IAuthAppDeps {
+    'core.domain.value': IValueDomain;
+    'core.domain.record': IRecordDomain;
+    'core.domain.apiKey': IApiKeyDomain;
+    'core.domain.user': IUserDomain;
+    'core.infra.cache.cacheService': ICachesService;
+    'core.utils.logger': winston.Winston;
+    'core.infra.oidc.oidcClientService': IOIDCClientService;
+    'core.app.helpers.initQueryContext': InitQueryContextFunc;
+    'core.app.helpers.convertOIDCIdentifier': IConvertOIDCIdentifier;
+    config: IConfig;
+}
+export default function ({ 'core.domain.value': valueDomain, 'core.domain.record': recordDomain, 'core.domain.apiKey': apiKeyDomain, 'core.domain.user': userDomain, 'core.utils.logger': logger, 'core.infra.cache.cacheService': cacheService, 'core.infra.oidc.oidcClientService': oidcClientService, 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.convertOIDCIdentifier': convertOIDCIdentifier, config }: IAuthAppDeps): IAuthApp;

package/apps/core/src/app/auth/index.d.ts

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

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

@@ -0,0 +1,13 @@
+import { IActionsListDomain } from 'domain/actionsList/actionsListDomain';
+import { i18n } from 'i18next';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IAppModule } from '_types/shared';
+export interface ICoreActionListApp extends IAppModule {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+}
+interface IDeps {
+    'core.domain.actionsList': IActionsListDomain;
+    translator: i18n;
+}
+export default function ({ 'core.domain.actionsList': actionsListDomain, translator }: IDeps): ICoreActionListApp;
+export {};

package/apps/core/src/app/core/apiKeyApp/_types.d.ts

@@ -0,0 +1,21 @@
+import { IApiKeyFilterOptions } from '_types/apiKey';
+import { IPaginationParams, SortOrder } from '_types/list';
+export interface IApiKeysArgs {
+    filters?: IApiKeyFilterOptions;
+    pagination: IPaginationParams;
+    sort: {
+        field: 'id';
+        order: SortOrder;
+    };
+}
+export interface ISaveApiKeyArgs {
+    apiKey: {
+        id: string;
+        label: string;
+        expiresAt: number;
+        userId: string;
+    };
+}
+export interface IDeleteApiKeyArgs {
+    id: string;
+}

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

@@ -0,0 +1,12 @@
+import { IApiKeyDomain } from 'domain/apiKey/apiKeyDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { IAppGraphQLSchema } from '_types/graphql';
+export interface ICoreVersionProfileApp {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+}
+interface IDeps {
+    'core.domain.apiKey': IApiKeyDomain;
+    'core.domain.record': IRecordDomain;
+}
+export default function ({ 'core.domain.apiKey': apiKeyDomain, 'core.domain.record': recordDomain }: IDeps): ICoreVersionProfileApp;
+export {};

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

@@ -0,0 +1,28 @@
+import { IActionsListDomain } from 'domain/actionsList/actionsListDomain';
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { ILibraryDomain } from 'domain/library/libraryDomain';
+import { IPermissionDomain } from 'domain/permission/permissionDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { ITreeDomain } from 'domain/tree/treeDomain';
+import { IVersionProfileDomain } from 'domain/versionProfile/versionProfileDomain';
+import { IUtils } from 'utils/utils';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IGraphqlApp } from '../../graphql/graphqlApp';
+import { ICoreApp } from '../coreApp';
+export interface ICoreAttributeApp {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+}
+interface IDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.library': ILibraryDomain;
+    'core.domain.record': IRecordDomain;
+    'core.domain.tree': ITreeDomain;
+    'core.domain.actionsList': IActionsListDomain;
+    'core.domain.permission': IPermissionDomain;
+    'core.domain.versionProfile': IVersionProfileDomain;
+    'core.app.graphql': IGraphqlApp;
+    'core.app.core': ICoreApp;
+    'core.utils': IUtils;
+}
+export default function (deps: IDeps): ICoreAttributeApp;
+export {};

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

@@ -0,0 +1,25 @@
+import { ISystemTranslationGenerator } from 'app/graphql/customScalars/systemTranslation/systemTranslation';
+import { ICoreDomain } from 'domain/core/coreDomain';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { GraphQLScalarType } from 'graphql';
+import { i18n } from 'i18next';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IAppModule } from '_types/shared';
+import { ISystemTranslation } from '_types/systemTranslation';
+import { IGraphqlApp } from '../graphql/graphqlApp';
+export interface ICoreApp extends IAppModule {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+    filterSysTranslationField(fieldData: ISystemTranslation, requestedLangs: string[]): ISystemTranslation | null;
+    initPubSubEventsConsumer(): Promise<void>;
+}
+export interface ICoreAppDeps {
+    'core.domain.core': ICoreDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.app.graphql': IGraphqlApp;
+    'core.app.graphql.customScalars.systemTranslation': ISystemTranslationGenerator;
+    'core.app.graphql.customScalars.dateTime': GraphQLScalarType;
+    'core.app.graphql.customScalars.any': GraphQLScalarType;
+    config: any;
+    translator: i18n;
+}
+export default function ({ 'core.domain.core': coreDomain, 'core.domain.eventsManager': eventsManagerDomain, 'core.app.graphql': graphqlApp, 'core.app.graphql.customScalars.systemTranslation': systemTranslation, 'core.app.graphql.customScalars.dateTime': DateTime, 'core.app.graphql.customScalars.any': Any, config, translator }: ICoreAppDeps): ICoreApp;

package/apps/core/src/app/core/coreApp.spec.d.ts

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

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

@@ -0,0 +1,12 @@
+import { InitQueryContextFunc } from 'app/helpers/initQueryContext';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { IConfig } from '_types/config';
+import { IAppModule } from '_types/shared';
+export type IEventsManagerApp = IAppModule;
+interface IDeps {
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.app.helpers.initQueryContext': InitQueryContextFunc;
+    config: IConfig;
+}
+export default function ({ 'core.app.helpers.initQueryContext': initQueryContext, 'core.domain.eventsManager': eventsManagerDomain, config }: IDeps): IEventsManagerApp;
+export {};

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

@@ -0,0 +1,10 @@
+import { IExportDomain } from 'domain/export/exportDomain';
+import { IAppGraphQLSchema } from '_types/graphql';
+export interface ICoreExportApp {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+}
+interface IDeps {
+    'core.domain.export': IExportDomain;
+}
+export default function ({ 'core.domain.export': exportDomain }: IDeps): ICoreExportApp;
+export {};

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

@@ -0,0 +1,21 @@
+import { InitQueryContextFunc } from 'app/helpers/initQueryContext';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { Express } from 'express';
+import { IConfig } from '_types/config';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IFilesManagerDomain } from '../../domain/filesManager/filesManagerDomain';
+import { ValidateRequestTokenFunc } from '../helpers/validateRequestToken';
+export interface IFilesManagerApp {
+    init(): Promise<void>;
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+    registerRoute(app: Express): void;
+}
+interface IDeps {
+    'core.app.helpers.initQueryContext': InitQueryContextFunc;
+    'core.app.helpers.validateRequestToken': ValidateRequestTokenFunc;
+    'core.domain.filesManager': IFilesManagerDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    config: IConfig;
+}
+export default function ({ 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.validateRequestToken': validateRequestToken, 'core.domain.filesManager': filesManagerDomain, 'core.domain.eventsManager': eventsManager, config }: IDeps): IFilesManagerApp;
+export {};

package/apps/core/src/app/core/formApp/_types.d.ts

@@ -0,0 +1,38 @@
+import { IForm, IFormDependentElements, IFormElement } from '_types/forms';
+import { IPaginationParams, ISortParams } from '_types/list';
+export type IFormForGraphql = Omit<IForm, 'elements'> & {
+    elements: IFormDependentElementsForGraphQL[];
+};
+export type IFormDependentElementsForGraphQL = Omit<IFormDependentElements, 'elements'> & {
+    elements: IFormElementForGraphQL[];
+};
+export type IFormElementForGraphQL = Omit<IFormElement, 'settings'> & {
+    settings: Array<{
+        key: string;
+        value: any;
+    }>;
+};
+export interface IGetFormArgs {
+    filters: ICoreEntityFilterOptions & {
+        library: string;
+        system?: boolean;
+    };
+    pagination: IPaginationParams;
+    sort: ISortParams;
+}
+export interface IGetRecordFormArgs {
+    recordId: string;
+    libraryId: string;
+    formId: string;
+    version?: Array<{
+        treeId: string;
+        treeNodeId: string;
+    }>;
+}
+export interface ISaveFormArgs {
+    form: IFormForGraphql;
+}
+export interface IDeleteFormArgs {
+    library: string;
+    id: string;
+}

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

@@ -0,0 +1,20 @@
+import { ConvertVersionFromGqlFormatFunc } from 'app/helpers/convertVersionFromGqlFormat';
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { IFormDomain } from 'domain/form/formDomain';
+import { ILibraryDomain } from 'domain/library/libraryDomain';
+import { IUtils } from 'utils/utils';
+import { IAppGraphQLSchema } from '_types/graphql';
+export interface ICoreFormApp {
+    getGraphQLSchema(): IAppGraphQLSchema;
+}
+interface IDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.form': IFormDomain;
+    'core.domain.library': ILibraryDomain;
+    'core.app.helpers.convertVersionFromGqlFormat': ConvertVersionFromGqlFormatFunc;
+    'core.utils': IUtils;
+}
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.domain.form': formDomain, 'core.domain.library': libraryDomain, 'core.app.helpers.convertVersionFromGqlFormat': convertVersionFromGqlFormat, 'core.utils': utils }: IDeps): {
+    getGraphQLSchema(): IAppGraphQLSchema;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { InitQueryContextFunc } from 'app/helpers/initQueryContext';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { Express } from 'express';
+import { IUtils } from 'utils/utils';
+import winston from 'winston';
+import { IConfig } from '_types/config';
+import { IAppGraphQLSchema } from '_types/graphql';
+import { IAppModule } from '_types/shared';
+import { IGlobalSettingsDomain } from '../../domain/globalSettings/globalSettingsDomain';
+export interface ICoreApp extends IAppModule {
+    getGraphQLSchema(): Promise<IAppGraphQLSchema>;
+    registerRoute(app: Express): void;
+}
+interface IDeps {
+    'core.app.helpers.initQueryContext': InitQueryContextFunc;
+    'core.domain.globalSettings': IGlobalSettingsDomain;
+    'core.domain.record': IRecordDomain;
+    'core.utils.logger': winston.Winston;
+    'core.utils': IUtils;
+    config: IConfig;
+}
+export default function ({ 'core.app.helpers.initQueryContext': initQueryContext, 'core.domain.globalSettings': globalSettingsDomain, 'core.domain.record': recordDomain, 'core.utils.logger': logger, 'core.utils': utils, config }: IDeps): ICoreApp;
+export {};