@aristid/leav-types 1.4.1-242090ba → 1.4.1-248b9e2b

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

@@ -63,6 +63,7 @@ export declare namespace mailer {
     export { port_1 as port };
     let secure_1: boolean;
     export { secure_1 as secure };
+    export let requireTLS: boolean;
     export namespace from {
         let name_1: string;
         export { name_1 as name };
@@ -92,7 +93,7 @@ export declare namespace matomo {
     export let siteId: string;
 }
 export declare namespace lang {
-    export let available: string | string[];
+    export let available: string[];
     let _default: string;
     export { _default as default };
 }
@@ -121,7 +122,8 @@ export declare namespace redis {
     export { host_2 as host };
     let port_3: string;
     export { port_3 as port };
-    export let database: number;
+    export let cacheDatabase: number;
+    export let sessionDatabase: number;
 }
 export declare namespace filesManager {
     namespace queues {
@@ -167,8 +169,7 @@ export declare namespace eventsManager {
     }
     export { routingKeys_2 as routingKeys };
     export namespace queues_2 {
-        let pubsub_events_1: string;
-        export { pubsub_events_1 as pubsub_events };
+        let pubsub_events_prefix: string;
     }
     export { queues_2 as queues };
 }
@@ -200,6 +201,19 @@ export declare namespace preview {
     let directory_3: string;
     export { directory_3 as directory };
 }
+export declare namespace notification {
+    let enable_3: boolean;
+    export { enable_3 as enable };
+    export namespace email_3 {
+        let enable_4: boolean;
+        export { enable_4 as enable };
+    }
+    export { email_3 as email };
+    export namespace webSocket {
+        let enable_5: boolean;
+        export { enable_5 as enable };
+    }
+}
 export declare namespace applications {
     let rootFolder: string;
 }
@@ -208,8 +222,8 @@ export declare namespace files {
     let originalsPathPrefix: string;
 }
 export declare namespace dbProfiler {
-    let enable_3: boolean;
-    export { enable_3 as enable };
+    let enable_6: boolean;
+    export { enable_6 as enable };
 }
 export declare namespace elasticsearch {
     export let indexPrefix: string;
@@ -221,5 +235,5 @@ export declare namespace elasticsearch {
 export declare namespace logsCollector {
     let queue: string;
 }
-export declare let pluginsPath: string | any[];
+export declare let pluginsPath: string[];
 export { _export as export, _import as import };

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

@@ -6,6 +6,10 @@ export namespace server {
         let password: string;
         let email: string;
     }
+    namespace systemUser {
+        let email_1: string;
+        export { email_1 as email };
+    }
     let allowIntrospection: boolean;
 }
 export namespace db {
@@ -22,33 +26,63 @@ export namespace filesManager {
     }
 }
 export namespace eventsManager {
-    namespace routingKeys {
+    export namespace routingKeys {
         let data_events: string;
+        let pubsub_events: string;
+    }
+    export namespace queues_1 {
+        let pubsub_events_prefix: string;
     }
+    export { queues_1 as queues };
 }
 export namespace indexationManager {
-    export namespace queues_1 {
+    export namespace queues_2 {
         let events_1: string;
         export { events_1 as events };
     }
-    export { queues_1 as queues };
+    export { queues_2 as queues };
 }
 export namespace tasksManager {
-    export namespace queues_2 {
-        let orders: string;
+    export let checkingInterval: number;
+    export namespace queues_3 {
+        let execOrders: string;
+        let cancelOrders: string;
     }
-    export { queues_2 as queues };
+    export { queues_3 as queues };
     export namespace routingKeys_1 {
-        let orders_1: string;
-        export { orders_1 as orders };
+        let execOrders_1: string;
+        export { execOrders_1 as execOrders };
+        let cancelOrders_1: string;
+        export { cancelOrders_1 as cancelOrders };
     }
     export { routingKeys_1 as routingKeys };
 }
 export namespace logs {
     let transport: string;
 }
+export namespace notification {
+    export let enable: boolean;
+    export namespace email_2 {
+        let enable_1: boolean;
+        export { enable_1 as enable };
+    }
+    export { email_2 as email };
+    export namespace webSocket {
+        let enable_2: boolean;
+        export { enable_2 as enable };
+    }
+}
+export namespace mailer {
+    namespace from {
+        let name_1: string;
+        export { name_1 as name };
+        let email_3: string;
+        export { email_3 as email };
+    }
+}
 export let debug: boolean;
 export namespace redis {
-    let database: number;
+    let cacheDatabase: number;
+    let sessionDatabase: number;
 }
 export let pluginsPath: string[];

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

@@ -1,9 +1,16 @@
+import WebSocket from 'ws';
+import { type Client as GraphqlWsClient } from 'graphql-ws';
+import { type AxiosResponse } from 'axios';
 import type FormData from 'form-data';
 import { type ActionsListConfig } from '_types/actionsList';
 import { type ITreeElement } from '_types/tree';
 import { AttributeFormats, type AttributeTypes, type IAttributeVersionsConf, type IEmbeddedAttribute } from '../../../_types/attribute';
 export declare function getGraphQLUrl(): Promise<string>;
-export declare function makeGraphQlCall(query: string | FormData, throwOnErrors?: boolean): Promise<any>;
+export declare class E2EGraphQLError extends Error {
+    readonly response: AxiosResponse;
+    constructor(message: string, response: AxiosResponse);
+}
+export declare function makeGraphQlCall(query: string | FormData): Promise<any>;
 export declare function gqlSaveLibrary(id: string, label: string, additionalAttributes?: string[]): Promise<any>;
 export declare function gqlSaveApplication(id: string, label: string, endpoint: string): Promise<any>;
 export declare function gqlSaveAttribute(params: {
@@ -41,3 +48,10 @@ export declare function gqlSaveVersionProfile(profileId: string, label: string,
  * Convert object to JSON, escaping quotes to be able to use it in a graphql query
  **/
 export declare function toCleanJSON(obj: {}): string;
+export declare function makeWebSocketGraphQlCall(): Promise<GraphqlWsClient>;
+export declare function waitGraphqlWebSocketMessage<T>(client: GraphqlWsClient, query: string, variables: Record<string, any>, acceptMessage: (msg: T) => boolean, { timeoutMs }: {
+    timeoutMs: any;
+}): Promise<T>;
+export declare function waitWebSocketMessage<T>(webSocket: WebSocket, acceptMessage: (msg: T) => boolean, { timeoutMs }: {
+    timeoutMs: any;
+}): Promise<T>;

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

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

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

@@ -0,0 +1,21 @@
+interface IMailpitMsgLight {
+    From: {
+        Name: string;
+        Address: string;
+    };
+    ID: string;
+    MessageID: string;
+    Read: boolean;
+    Size: number;
+    Subject: string;
+    To: Array<{
+        Name: string;
+        Address: string;
+    }>;
+}
+interface IMailpitMsgFull extends IMailpitMsgLight {
+    HTML: string;
+    Text: string;
+}
+export declare function waitMailpitMessage(acceptMessage: (msg: IMailpitMsgLight) => boolean): Promise<IMailpitMsgFull>;
+export {};

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

@@ -16,6 +16,7 @@ export interface IConfig {
     indexationManager: IIndexationManager;
     tasksManager: ITasksManager;
     eventsManager: IEventsManager;
+    notification: INotificationConfig;
     debug?: boolean;
     env?: string;
     defaultUserId: string;
@@ -97,7 +98,14 @@ export interface IAuth {
 export interface IMailer {
     host: string;
     port: number;
+    /**
+     * If true, use SSL/TLS connection (usually port 465). If false, use STARTTLS (usually port 587)
+     */
     secure: boolean;
+    /**
+     * If true, require TLS for the connection (STARTTLS). Only used if secure is false
+     */
+    requireTLS: boolean;
     from: {
         name: string;
         email: string;
@@ -124,7 +132,8 @@ export interface IAmqp {
 export interface IRedis {
     host: string;
     port: number;
-    database: number;
+    cacheDatabase: number;
+    sessionDatabase: number;
 }
 export interface IFilesManager {
     queues: {
@@ -149,7 +158,7 @@ export interface IEventsManager {
         pubsub_events: string;
     };
     queues: {
-        pubsub_events: string;
+        pubsub_events_prefix: string;
     };
 }
 export interface IIndexationManager {
@@ -226,6 +235,15 @@ export interface IFilesConfig {
 export interface IDbProfilerConfig {
     enable: boolean;
 }
+export interface INotificationConfig {
+    enable: boolean;
+    email: {
+        enable: boolean;
+    };
+    webSocket: {
+        enable: boolean;
+    };
+}
 export interface IElasticsearchConfig {
     indexPrefix: string;
     url: string;

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

@@ -1,6 +1,7 @@
 export declare enum ErrorTypes {
     VALIDATION_ERROR = "VALIDATION_ERROR",
     PERMISSION_ERROR = "PERMISSION_ERROR",
+    CUSTOM_CONFIG_ERROR = "CUSTOM_CONFIG_ERROR",
     INTERNAL_ERROR = "INTERNAL_ERROR"
 }
 export declare enum Errors {

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

@@ -1,8 +1,16 @@
+import { type INotificationContent } from './notification';
 export declare enum TriggerNames {
     APPLICATION_EVENT = "APPLICATION_EVENT",
     UPLOAD_FILE = "UPLOAD_FILE",
     INDEXATION = "INDEXATION",
     TASK = "TASK",
     TREE_EVENT = "TREE_EVENT",
-    RECORD_UPDATE = "RECORD_UPDATE"
+    RECORD_UPDATE = "RECORD_UPDATE",
+    NOTIFICATION = "NOTIFICATION"
+}
+export interface IPubSubNotificationData {
+    notification: INotificationContent & {
+        date: number;
+    };
+    recipientUserIds: string[];
 }

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

@@ -0,0 +1,51 @@
+import { type IQueryInfos } from './queryInfos';
+export interface INotification {
+    /**
+     * Timestamp of the notification creation in milliseconds since epoch
+     */
+    date: number;
+    /**
+     * User ID of the notification recipient
+     */
+    recipientUserId: string;
+    content: INotificationContent;
+}
+export interface INotificationContent {
+    level: 'info' | 'warning';
+    title: string;
+    message: string;
+    relatedEntities?: Array<{
+        url: string;
+        label: string;
+    }>;
+    attachments?: Array<{
+        url: string;
+        label: string;
+    }>;
+}
+export interface ICreateNotification {
+    emitterUserId: string;
+    /**
+     * Recipients of the notification, need at least one userId or groupId
+     */
+    recipients: {
+        userIds: string[];
+        /**
+         * No implementation yet
+         */
+        groupIds: string[];
+    };
+    /**
+     * Priority of the notification, may change which channel is used to send it (no yet implemented)
+     */
+    priority: 'urgent' | 'normal';
+    content: INotificationContent;
+}
+export declare enum NotificationChannels {
+    EMAIL = "email",
+    WEB_SOCKET = "web_socket"
+}
+export interface INotificationChannel {
+    type: NotificationChannels;
+    sendNotifications(notifications: INotification[], ctx: IQueryInfos): Promise<void>;
+}

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

@@ -2,3 +2,13 @@ export interface IUserData {
     global: boolean;
     data: any;
 }
+/**
+ * Same idea as IRecordIdentity but for users
+ */
+export interface IUserIdentity {
+    id: string;
+    /**
+     * @throw if user have no email
+     */
+    getEmail: () => Promise<string>;
+}

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

@@ -4,7 +4,6 @@ import { type IUserDomain } from 'domain/user/userDomain';
 import { type IValueDomain } from 'domain/value/valueDomain';
 import { type Response } from 'express';
 import { type IConfig } from '_types/config';
-import { type ICachesService } from '../../infra/cache/cacheService';
 import { type ITokenUserData } from '../../_types/auth';
 import { type IRequestWithContext } from '../../_types/express';
 import { type ILogger } from '@leav/logger';
@@ -16,6 +15,7 @@ import { type IRecordRepo } from '../../infra/record/recordRepo';
 import { type IGraphqlAppModule } from 'app/graphql/graphqlApp';
 import { type IServerRouteAppModule } from 'interface/server';
 import { type GetSystemQueryContext } from 'utils/helpers/getSystemQueryContext';
+import { type ISessionRepo } from '../../infra/session/sessionRepo';
 export interface IAuthApp extends IGraphqlAppModule, IServerRouteAppModule {
     validateRequestToken(params: {
         apiKey?: string;
@@ -30,12 +30,12 @@ export interface IAuthAppDeps {
     'core.infra.record': IRecordRepo;
     'core.domain.apiKey': IApiKeyDomain;
     'core.domain.user': IUserDomain;
-    'core.infra.cache.cacheService': ICachesService;
     'core.utils.logger': ILogger;
     'core.infra.oidc.oidcClientService': IOIDCClientService;
     'core.app.helpers.initQueryContext': InitQueryContextFunc;
     'core.app.helpers.convertOIDCIdentifier': IConvertOIDCIdentifier;
     'core.utils.getSystemQueryContext': GetSystemQueryContext;
     config: IConfig;
+    'core.infra.session': ISessionRepo;
 }
-export default function ({ 'core.domain.value': valueDomain, 'core.domain.record': recordDomain, 'core.infra.record': recordRepo, '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, 'core.utils.getSystemQueryContext': getSystemQueryContext, config }: IAuthAppDeps): IAuthApp;
+export default function ({ 'core.domain.value': valueDomain, 'core.domain.record': recordDomain, 'core.infra.record': recordRepo, 'core.domain.apiKey': apiKeyDomain, 'core.domain.user': userDomain, 'core.utils.logger': logger, 'core.infra.oidc.oidcClientService': oidcClientService, 'core.app.helpers.initQueryContext': initQueryContext, 'core.app.helpers.convertOIDCIdentifier': convertOIDCIdentifier, 'core.utils.getSystemQueryContext': getSystemQueryContext, 'core.infra.session': sessionRepo, config }: IAuthAppDeps): IAuthApp;

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

@@ -17,6 +17,7 @@ export { default as permission } from './permissionApp/permissionApp';
 export { default as plugins } from './pluginsApp';
 export { default as record } from './recordApp/recordApp';
 export { default as tasksManager } from './tasksManagerApp';
+export { default as notification } from './notificationApp';
 export { default as tree } from './treeApp/treeApp';
 export { default as userData } from './userDataApp';
 export { default as value } from './valueApp';

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

@@ -0,0 +1,10 @@
+import { type IGraphqlAppModule } from 'app/graphql/graphqlApp';
+import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { type IUtils } from 'utils/utils';
+export type INotificationApp = IGraphqlAppModule;
+interface IDeps {
+    'core.utils'?: IUtils;
+    'core.domain.eventsManager'?: IEventsManagerDomain;
+}
+export default function ({ 'core.domain.eventsManager': eventsManager }: IDeps): INotificationApp;
+export {};

package/apps/core/src/domain/export/exportDomain.d.ts

@@ -11,8 +11,11 @@ import { type IQueryInfos } from '../../_types/queryInfos';
 import { type IRecordFilterLight } from '../../_types/record';
 import { type ITaskFuncParams } from '../../_types/tasksManager';
 import { type IValidateHelper } from '../helpers/validate';
+import { type INotificationDomain } from 'domain/notification/notificationDomain';
+import { type IExportProfileDomain } from './exportProfileDomain';
 export interface IExportParams {
     library: string;
+    profile: string;
     attributes: string[];
     filters?: IRecordFilterLight[];
     ctx: IQueryInfos;
@@ -39,8 +42,10 @@ export interface IExportDomainDeps {
     'core.domain.helpers.validate': IValidateHelper;
     'core.domain.helpers.updateTaskProgress': UpdateTaskProgress;
     'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.notification': INotificationDomain;
+    'core.domain.export.exportProfile': IExportProfileDomain;
     'core.utils': IUtils;
     translator: i18n;
     config: Config.IConfig;
 }
-export default function ({ config, 'core.domain.record': recordDomain, 'core.domain.helpers.validate': validateHelper, 'core.domain.attribute': attributeDomain, 'core.domain.library': libraryDomain, 'core.domain.tasksManager': tasksManager, 'core.domain.helpers.updateTaskProgress': updateTaskProgress, 'core.domain.eventsManager': eventsManagerDomain, 'core.utils': utils, translator }: IExportDomainDeps): IExportDomain;
+export default function ({ config, 'core.domain.record': recordDomain, 'core.domain.helpers.validate': validateHelper, 'core.domain.attribute': attributeDomain, 'core.domain.library': libraryDomain, 'core.domain.tasksManager': tasksManager, 'core.domain.helpers.updateTaskProgress': updateTaskProgress, 'core.domain.eventsManager': eventsManagerDomain, 'core.domain.notification': notificationDomain, 'core.domain.export.exportProfile': exportProfileDomain, 'core.utils': utils, translator }: IExportDomainDeps): IExportDomain;

package/apps/core/src/domain/export/exportProfileDomain.d.ts

@@ -0,0 +1,23 @@
+import { type ILibraryDomain } from '../library/libraryDomain';
+import { type IQueryInfos } from '../../_types/queryInfos';
+export interface IExportProfileConfig {
+    profileSelected: string;
+    profiles: Array<{
+        label: string;
+        columns: Array<{
+            columnLabel: string;
+            attribute: string;
+        }>;
+    }>;
+}
+export interface IExportColumn {
+    columnLabel: string;
+    attribute: string;
+}
+export interface IExportProfileDomain {
+    getColumnsFromProfileConfig(profile: string, library: string, ctx: IQueryInfos): Promise<IExportColumn[]>;
+}
+export interface IExportProfileDomainDeps {
+    'core.domain.library': ILibraryDomain;
+}
+export default function ({ 'core.domain.library': libraryDomain }: IExportProfileDomainDeps): IExportProfileDomain;

package/apps/core/src/domain/export/exportProfileDomain.spec.d.ts

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

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

@@ -1 +1,2 @@
 export { default } from './exportDomain';
+export { default as exportProfile } from './exportProfileDomain';

package/apps/core/src/domain/notification/channels/emailChannel.d.ts

@@ -0,0 +1,12 @@
+import { type INotificationChannel } from '../../../_types/notification';
+import { type IMailerService } from 'infra/mailer/mailerService';
+import { type IUserDomain } from 'domain/user/userDomain';
+import { type IGlobalSettingsDomain } from 'domain/globalSettings/globalSettingsDomain';
+import { type IConfig } from '_types/config';
+export interface INotificationByEmailChannelDeps {
+    config: IConfig;
+    'core.infra.mailer.mailerService': IMailerService;
+    'core.domain.globalSettings': IGlobalSettingsDomain;
+    'core.domain.user': IUserDomain;
+}
+export default function ({ config, 'core.infra.mailer.mailerService': mailerService, 'core.domain.globalSettings': globalSettingsDomain, 'core.domain.user': userDomain }: INotificationByEmailChannelDeps): INotificationChannel;

package/apps/core/src/domain/notification/channels/webSocketChannel.d.ts

@@ -0,0 +1,6 @@
+import { type INotificationChannel } from '../../../_types/notification';
+import { type IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+export interface INotificationByWebSocketChannelDeps {
+    'core.domain.eventsManager': IEventsManagerDomain;
+}
+export default function ({ 'core.domain.eventsManager': eventsManagerDomain }: INotificationByWebSocketChannelDeps): INotificationChannel;

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

@@ -0,0 +1,3 @@
+export { default } from './notificationDomain';
+export { default as emailChannel } from './channels/emailChannel';
+export { default as webSocketChannel } from './channels/webSocketChannel';

package/apps/core/src/domain/notification/notificationDomain.d.ts

@@ -0,0 +1,12 @@
+import { type IConfig } from '_types/config';
+import { type INotificationChannel, type ICreateNotification } from '_types/notification';
+import { type IQueryInfos } from '_types/queryInfos';
+export interface INotificationDomain {
+    createNotification(notification: ICreateNotification, ctx: IQueryInfos): Promise<void>;
+}
+export interface INotificationDomainDeps {
+    'core.domain.notification.emailChannel': INotificationChannel;
+    'core.domain.notification.webSocketChannel': INotificationChannel;
+    config: IConfig;
+}
+export default function ({ 'core.domain.notification.emailChannel': emailChannel, 'core.domain.notification.webSocketChannel': webSocketChannel, config }: INotificationDomainDeps): INotificationDomain;

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

@@ -6,7 +6,8 @@ import { type IUserDataRepo } from 'infra/userData/userDataRepo';
 import { type IUtils } from 'utils/utils';
 import type * as Config from '_types/config';
 import { type IQueryInfos } from '_types/queryInfos';
-import { type IUserData } from '_types/userData';
+import { type IUserIdentity, type IUserData } from '_types/userData';
+import { type IValueDomain } from 'domain/value/valueDomain';
 interface ISaveUserDataParams {
     key: string;
     value: any;
@@ -15,12 +16,14 @@ interface ISaveUserDataParams {
     ctx: IQueryInfos;
 }
 export interface IUserDomain {
+    getUserIdentity(userId: string, ctx: IQueryInfos): Promise<IUserIdentity>;
     saveUserData(params: ISaveUserDataParams): Promise<IUserData>;
     getUserData(keys: string[], global: boolean, ctx: IQueryInfos): Promise<IUserData>;
     sendResetPasswordEmail(email: string, token: string, login: string, browser: string, os: string, lang: 'fr' | 'en', ctx: IQueryInfos): Promise<void>;
 }
 export interface IUserDomainDeps {
     config: Config.IConfig;
+    'core.domain.value': IValueDomain;
     'core.domain.permissions': IPermissionDomain;
     'core.infra.userData': IUserDataRepo;
     'core.domain.permission': IPermissionDomain;
@@ -32,5 +35,5 @@ export interface IUserDomainDeps {
 export declare enum UserCoreDataKeys {
     CONSULTED_APPS = "applications_consultation"
 }
-export default function ({ config, 'core.infra.userData': userDataRepo, 'core.domain.permission': permissionDomain, 'core.infra.mailer.mailerService': mailerService, 'core.domain.globalSettings': globalSettingsDomain, 'core.utils': utils, translator }: IUserDomainDeps): IUserDomain;
+export default function ({ config, 'core.domain.value': valueDomain, 'core.infra.userData': userDataRepo, 'core.domain.permission': permissionDomain, 'core.infra.mailer.mailerService': mailerService, 'core.domain.globalSettings': globalSettingsDomain, 'core.utils': utils, translator }: IUserDomainDeps): IUserDomain;
 export {};

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

@@ -88,11 +88,6 @@ export interface IValueDomain {
         ctx: IQueryInfos;
     }): Promise<IValue>;
     runActionsList(params: IRunActionListParams): Promise<IValue[]>;
-    runActionsListAndFormatOnValue({ library, value, ctx }: {
-        library: string;
-        value: IValue;
-        ctx: IQueryInfos;
-    }): Promise<IValue[]>;
 }
 export interface IValueDomainDeps {
     config: Config.IConfig;

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

@@ -0,0 +1,4 @@
+import LeavError from './LeavError';
+export default class CustomConfigError<T> extends LeavError<T> {
+    constructor(message?: string);
+}

package/apps/core/src/infra/cache/cacheService.d.ts

@@ -1,4 +1,5 @@
 import { type IQueryInfos } from '_types/queryInfos';
+import { type IRedis } from './redis';
 export interface IMemoizeParams<T> {
     key: string;
     func: () => Promise<T>;
@@ -21,13 +22,13 @@ export interface ICacheService {
     deleteData(keys: string[], path?: string): Promise<void>;
     deleteAll(path?: string): Promise<void>;
 }
-interface IDeps {
-    'core.infra.cache.ramService': ICacheService;
+interface ICacheServiceDeps {
+    'core.infra.redis': IRedis;
     'core.infra.cache.diskService': ICacheService;
 }
 export declare enum ECacheType {
     DISK = "DISK",
     RAM = "RAM"
 }
-export default function ({ 'core.infra.cache.ramService': ramService, 'core.infra.cache.diskService': diskService }: IDeps): ICachesService;
+export default function ({ 'core.infra.redis': redis, 'core.infra.cache.diskService': diskService }: ICacheServiceDeps): ICachesService;
 export {};

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

@@ -1,4 +1,3 @@
 export { initRedis } from './redis';
-export { default as diskService } from './diskService';
-export { default as ramService } from './ramService';
 export { default as cacheService } from './cacheService';
+export { default as diskService } from './diskService';

package/apps/core/src/infra/cache/ramService.d.ts

@@ -1,9 +1,3 @@
 import { type ICacheService } from './cacheService';
 import { type RedisClientType } from './redis';
-import { type IConfig } from '../../_types/config';
-interface IDeps {
-    config?: IConfig;
-    'core.infra.redis'?: RedisClientType;
-}
-export default function ({ 'core.infra.redis': redis, config }: IDeps): ICacheService;
-export {};
+export default function (redisClient: RedisClientType): ICacheService;

package/apps/core/src/infra/cache/redis.d.ts

@@ -4,5 +4,9 @@ interface IDeps {
     config?: IConfig;
 }
 export type RedisClientType = ReturnType<typeof redis.createClient>;
-export declare function initRedis({ config }: IDeps): Promise<RedisClientType>;
+export interface IRedis {
+    cache: RedisClientType;
+    session: RedisClientType;
+}
+export declare function initRedis({ config }: IDeps): Promise<IRedis>;
 export {};

package/apps/core/src/infra/oidc/oidcClientService.d.ts

@@ -1,7 +1,7 @@
 import { type OidcClient } from './oidcClient';
 import { TokenSet } from 'openid-client';
-import { type ICachesService } from '../cache/cacheService';
 import { type IConfig } from '../../_types/config';
+import { type ISessionRepo } from '../session/sessionRepo';
 export interface IOIDCClientService {
     oidcClient?: OidcClient;
     getTokensFromCodes: (params: {
@@ -30,8 +30,8 @@ export interface IOIDCClientService {
 }
 interface IDeps {
     'core.infra.oidcClient'?: OidcClient;
-    'core.infra.cache.cacheService'?: ICachesService;
     config?: IConfig;
+    'core.infra.session'?: ISessionRepo;
 }
-export default function ({ 'core.infra.oidcClient': oidcClient, 'core.infra.cache.cacheService': cacheService, config }?: IDeps): IOIDCClientService;
+export default function ({ 'core.infra.oidcClient': oidcClient, 'core.infra.session': sessionRepo, config }?: IDeps): IOIDCClientService;
 export {};

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

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

package/apps/core/src/infra/session/sessionRepo.d.ts

@@ -0,0 +1,8 @@
+import { type ICacheService } from '../cache/cacheService';
+import { type IRedis } from '../cache/redis';
+export type ISessionRepo = ICacheService;
+interface ISessionRepoDeps {
+    'core.infra.redis'?: IRedis;
+}
+export default function ({ 'core.infra.redis': redis }: ISessionRepoDeps): ISessionRepo;
+export {};

package/libs/config-manager/src/envTo.d.ts

@@ -6,3 +6,7 @@ export declare function envToBool(value: string, defaultValue?: boolean): boolea
  * To convert process.env string to number
  */
 export declare function envToNumber(value: string, defaultValue?: number): number;
+/**
+ * To convert process.env string to string array
+ */
+export declare function envToStringArray(value: string, separator?: string, defaultValue?: string[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aristid/leav-types",
-  "version": "1.4.1-242090ba",
+  "version": "1.4.1-248b9e2b",
   "description": "Shared Leav types",
   "scripts": {
     "tscheck": "",