proteum 1.0.0-1

package/server/services/cache/commands.ts

@@ -0,0 +1,41 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import sizeOf from 'object-sizeof';
+
+// Core
+
+// Specific
+import type CacheManager from '.';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default (cache: CacheManager, app = cache.app) => [
+
+   app.command('cache', 'Manage the cache service', [
+
+        app.command('list', 'List cache entries', async () => {
+
+            return Object.entries(cache.data).map(([ key, entry ]) => ({
+                key,
+                type: typeof entry?.value,
+                size: sizeOf(entry?.value),
+                expires: entry?.expiration || 'No expiration'
+            }))
+        }),
+
+        app.command('delete', 'List cache entries', async (key?: string) => {
+
+            await cache.del(key);
+
+            return true;
+        })
+   ])
+]

package/server/services/cache/index.ts

@@ -0,0 +1,297 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Node
+import path from 'path';
+
+// Npm
+import hInterval from 'human-interval';
+
+// Core
+import type { Application } from '@server/app';
+import Service, { AnyService, TRegisteredService } from '@server/app/service';
+import type { default as DisksManager, Driver } from '../disks';
+
+// Specific
+import registerCommands from './commands';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+const LogPrefix = '[cache]';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TPrimitiveValue = string | boolean | number | undefined | TPrimitiveValue[] | {
+    [key: string]: TPrimitiveValue
+}
+
+type TExpirationDelay = 'never' | string | number | Date;
+
+type CacheEntry<TValue extends TPrimitiveValue =TPrimitiveValue > = { 
+    // Value
+    value: TValue, 
+    // Expiration Timestamp
+    expiration?: number,
+    changes: number
+};
+
+type TCacheGetOrUpdateArgs<TValeur extends TPrimitiveValue> = [
+    cle: string, 
+    func: (() => Promise<TValeur>),
+    expiration?: TExpirationDelay,
+    avecDetails?: boolean
+]
+
+type TCacheGetOnlyArgs = [
+    cle: string, 
+    avecDetails: true
+]
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type Config = {
+    debug: boolean,
+    disk: string, // TODO: keyof disks
+    disks: DisksManager
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class Cache extends Service<Config, Hooks, Application> {
+
+    public commands = registerCommands(this);
+
+    public data: {[key: string]: CacheEntry | undefined} = {};
+
+    private disk: Driver;
+
+    public constructor( 
+        parent: AnyService, 
+        config: Config,
+        app: Application, 
+    ) {
+
+        super(parent, config, app);
+
+        this.disk = this.config.disks.get(config.disk)
+    }
+
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    public async ready() {
+
+        setInterval(() => this.cleanMem(), 10000);
+    }
+
+    public async shutdown() {
+
+    }
+
+    /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+    private async restore() {
+        const files = await this.disk.readDir('data', 'cache')
+        for (const file of files) {
+
+            if (!file.name.endsWith('.json'))
+                continue;
+
+            const entryKey = file.name.substring(0, file.name.length - 5);
+            const filePath = path.join('cache', file.name);
+            this.data[ entryKey ] = await this.disk.readJSON('data', filePath);
+            console.log(LogPrefix, `Restored cache entry ${entryKey}`);
+        }
+    }
+
+    private cleanMem() {
+
+        // Remove expired data
+        const now = Date.now();
+        for (const key in this.data) {
+            const entry = this.data[ key ];
+            if (entry?.expiration && entry.expiration < now) {
+                this.config.debug && console.log(LogPrefix, `Delete expired data: ${key}`);
+                this.del(key);
+            }
+        }
+        
+        // Write changes
+        for (const entryKey in this.data) {
+
+            const entry = this.data[entryKey];
+            if (!entry?.changes)
+                continue;
+
+            this.config.debug && console.log(LogPrefix, `Flush ${entry.changes} changes for ${entryKey}`);
+
+            entry.changes = 0;
+            const entryFile = this.getEntryFile(entryKey);
+            fs.outputJSONSync(entryFile , this.data[entryKey]);
+        }
+    }
+
+    private getEntryFile( entryKey: string ) {
+        return path.join(this.cacheDir, entryKey + '.json');
+    }
+
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        avecDetails?: true
+    ): Promise<CacheEntry<TValeur> | TValeur | undefined>;
+
+    // Expiration = Durée de vie en secondes ou date max
+    // Retourne null quand pas de valeur
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        func: (() => Promise<TValeur>),
+        expiration: TExpirationDelay,
+        avecDetails: true
+    ): Promise<CacheEntry<TValeur>>;
+
+    public get<TValeur extends TPrimitiveValue>(
+        cle: string, 
+        func: (() => Promise<TValeur>),
+        expiration?: TExpirationDelay,
+        avecDetails?: false
+    ): Promise<TValeur>;
+
+    public async get<TValeur extends TPrimitiveValue, TArgs extends TCacheGetOnlyArgs | TCacheGetOrUpdateArgs<TValeur> = TCacheGetOnlyArgs | TCacheGetOrUpdateArgs<TValeur>>(
+        ...args: TArgs
+    ): Promise< TValeur | CacheEntry<TValeur> | (TArgs extends TCacheGetOnlyArgs ? undefined : TValeur)> {
+
+        let cle: string;
+        let func: (() => Promise<TValeur>) | undefined;
+        let expiration: TExpirationDelay | undefined;
+        let avecDetails: boolean | undefined = true;
+
+        if (typeof args[1] === 'function') {
+            ([ cle, func, expiration, avecDetails ] = args);
+        } else {
+            ([ cle, avecDetails ] = args);
+        }
+
+        if (expiration === undefined)
+            expiration = 'never';
+
+        let entry: CacheEntry<TValeur> | undefined = this.data[cle];
+
+        // Expired
+        if (entry?.expiration && entry.expiration < Date.now()){
+            this.config.debug && console.log(LogPrefix, `Key ${cle} expired.`);
+            entry = undefined;
+        }
+
+        // Donnée inexistante
+        if (entry !== undefined) {
+
+            this.config.debug && console.log(LogPrefix, `Get "${cle}": restored via cache`);
+            
+        } else if (func !== undefined) {
+
+            this.config.debug && console.log(LogPrefix, `Get "${cle}": refresh value`);
+
+            // Rechargement
+            entry = {
+                value: await func(),
+                expiration: this.delayToTimestamp(expiration),
+                changes: 0
+            }
+
+            if (expiration !== 'now')
+                await this.set(cle, entry.value, expiration);
+
+        } else
+            return undefined;
+
+        return avecDetails 
+            ? entry
+            : entry.value as TValeur;
+    };
+
+    /**
+     * Put in cache a JSON value, associated with an unique ID.
+     * @param cle Unique identifier for the cache entry. Used to retrieve the value via Cache.set()
+     * @param val The value to put in cache
+     * @param expiration The interval in which the data is valid.
+     *  - string: the humain-readable expression. Exemple: 10 minutes
+     *  - number: time in seconds
+     *  - Date: the date at which the data expires
+     *  - null: no expiration (default)
+     * @returns A void promise
+     */
+    public set( cle: string, val: TPrimitiveValue, expiration: TExpirationDelay = 'never' ): void {
+
+        // TODO: check is key contains illegal characters
+    
+        this.config.debug && console.log(LogPrefix, "Updating cache " + cle);
+        this.data[ cle ] = {
+            value: val,
+            expiration: this.delayToTimestamp(expiration),
+            changes: 1
+        }
+    };
+
+    public del( key: string ): void {
+
+        if (key === undefined) {
+            this.data = {};
+            console.log(LogPrefix, "Deleting all keys from cache");
+            fs.removeSync( this.cacheDir );
+        } else {
+            this.data[ key ] = undefined;
+            console.log(LogPrefix, `Deleting key "${key}" from cache`);
+            const entryFile = this.getEntryFile(key);
+            fs.removeSync( entryFile );
+        }
+    }
+
+
+    /*----------------------------------
+    - UTILS
+    ----------------------------------*/
+    /**
+     * 
+     * @param delay 
+     * @returns number (timestamp when the data expired) or undefined (never expires)
+     */
+    private delayToTimestamp( delay: TExpirationDelay ): number | undefined {
+
+        if (delay === 'now') {
+
+            return Date.now();
+
+        } else if (delay === 'never') {
+
+            return undefined;
+
+        // H expression
+        } else if (typeof delay === 'string') {
+
+            const ms = hInterval(delay); 
+            if (ms === undefined) throw new Error(`Invalid period string: ` + delay);
+            return Date.now() + ms;
+
+        // Lifetime in seconds
+        } else if (typeof delay === 'number')
+            return Date.now() + delay;
+
+        // Date limit
+        else
+            return delay.getTime();
+    }
+}

package/server/services/cache/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Cache",
+    "name": "Cache",
+    "parent": "app",
+    "dependences": []
+}

package/server/services/cron/CronTask.ts

@@ -0,0 +1,86 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import cronParser, { CronExpression } from 'cron-parser';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import type CronManager from '.';
+
+export type TFrequence = string | Date;
+export type TRunner = () => Promise<any>
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+export default class CronTask {
+
+    public cron?: CronExpression
+    public nextInvocation?: Date;
+
+    public constructor(
+        private manager: CronManager,
+        public nom: string,
+        next: TFrequence,
+        public runner: TRunner,
+        public autoexec?: boolean
+    ) {
+
+        this.manager.config.debug && console.info(`[cron][${this.nom}] Enregistrement de la tâche`);
+
+        this.schedule(next);
+
+    }
+
+    public schedule(next: TFrequence) {
+
+        this.cron = undefined;
+
+        // Cron expression
+        if (typeof next === 'string') {
+
+            this.cron = cronParser.parseExpression(next);
+            this.nextInvocation = this.cron.next().toDate();
+
+            this.manager.config.debug && 
+                console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via cron ${next}`);
+
+            // Date
+        } else {
+
+            this.nextInvocation = next;
+            this.manager.config.debug && 
+                console.info(`[cron][${this.nom}] Planifié pour ${this.nextInvocation.toISOString()} via date`);
+
+        }
+    }
+
+    public scheduleNext() {
+
+        // Prochaine invocation
+        if (this.cron !== undefined)
+            this.nextInvocation = this.cron.next().toDate();
+        else
+            this.nextInvocation = undefined;
+    }
+
+    public run(now: boolean = false) {
+
+        // Update invocation date
+        const maintenant = new Date
+        const runnable = this.nextInvocation !== undefined && this.nextInvocation.valueOf() <= maintenant.valueOf()
+        if (runnable)
+            this.scheduleNext();
+        else if (now === false)
+            return;
+
+        // Execution
+        this.runner().then(() => {
+            this.manager.config.debug && console.info(`Task runned.`);
+        })
+    }
+}

package/server/services/cron/index.ts

@@ -0,0 +1,112 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
+import { NotFound } from '@common/errors';
+import context from '@server/context';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+import CronTask, { TRunner, TFrequence } from './CronTask';
+
+export { default as CronTask } from './CronTask';
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+export type Config = {
+   debug?: boolean
+}
+
+export type Hooks = {
+
+}
+
+export type Services = {
+
+}
+
+/*----------------------------------
+- CLASSE
+----------------------------------*/
+
+export default class CronManager extends Service<Config, Hooks, Application, Application> {
+
+    public static taches: { [nom: string]: CronTask } = {}
+    public static timer: NodeJS.Timeout;
+
+    /*----------------------------------
+    - LIFECICLE
+    ----------------------------------*/
+
+    public async ready() {
+
+        clearInterval(CronManager.timer);
+        CronManager.timer = setInterval(() => {
+
+            for (const id in CronManager.taches)
+                CronManager.taches[id].run();
+
+        }, 10000);
+  
+    }
+
+    /*----------------------------------
+    - STATIQUE
+    ----------------------------------*/
+
+    /**
+     * Create a new Cron task
+     * @param nom Unique ID / Label for this task (helpful for tracking & debugging)
+     * @param frequence When to execute this task.
+     *  - Date: The date at which to execute this task (one time execution)
+     *  - string: Cron expression to define the interval for executing this task
+     * @param run Function to run 
+     * @param autoexec true to execute the task immediatly
+     * @returns The CronTask that just have been created
+     */
+    public task(nom: string, frequence: TFrequence, run: TRunner, autoexec?: boolean) {
+        return new Promise<CronTask>((resolve, reject) => {
+            context.run({ channelType: 'cron', channelId: nom }, async () => {
+
+                CronManager.taches[nom] = new CronTask(this, nom, frequence, run, autoexec);
+
+                if (autoexec)
+                    await CronManager.taches[nom].run(true);
+
+                resolve( CronManager.taches[nom] );
+
+            })
+        });
+
+    }
+
+    public async exec(nom: string) {
+
+        const tache = CronManager.taches[nom];
+
+        if (tache === undefined)
+            throw new NotFound("Tâche NotFound: " + nom);
+
+        await tache.run(true);
+
+    }
+    public get(): typeof CronManager.taches;
+    public get(name: string): CronTask;
+    public get(name?: string): CronTask | typeof CronManager.taches {
+
+        if (name === undefined)
+            return CronManager.taches;
+
+        const cron = CronManager.taches[name];
+        if (cron === undefined)
+            throw new Error(`L'instance de la tâche cron ${name} n'a pas été trouvée`);
+        return cron;
+    }
+}

package/server/services/cron/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Cron",
+    "name": "Cron",
+    "parent": "app",
+    "dependences": []
+}

package/server/services/disks/driver.ts

@@ -0,0 +1,103 @@
+/*----------------------------------
+- DEPS
+----------------------------------*/
+
+// Core
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
+
+/*----------------------------------
+- CONFIG
+----------------------------------*/
+
+export type THooks = {
+
+}
+
+export type Services = {
+
+}
+
+/*----------------------------------
+- TYPE
+----------------------------------*/
+
+export type TDrivercnfig = {
+
+    debug: boolean,
+
+    rootDir: string,
+    buckets: {
+        [id: string]: string
+    }
+}
+
+export type SourceFile = { 
+    name: string, 
+    path: string, 
+    modified: number, 
+    parentFolder: string,
+    source: string 
+}
+
+export type TOutputFileOptions = {
+    encoding: string
+}
+
+export type TReadFileOptions = {
+    encoding?: 'string'|'buffer',
+    withMetas?: boolean
+}
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+
+export default abstract class FsDriver<
+    Config extends TDrivercnfig = TDrivercnfig,
+    TBucketName = keyof Config["buckets"]
+> extends Service<Config, {}, Application, Application> {
+
+    public constructor( config: Config, app: Application ) {
+        super(app, config, app);
+    }
+
+    public abstract mount(): Promise<void>;
+
+    public abstract getFileUrl(
+        bucketName: TBucketName, 
+        filename: string
+    ): string;
+    
+    public abstract readDir( bucketName: TBucketName, dirname?: string ): Promise<SourceFile[]>;
+
+    public abstract readFile( 
+        bucketName: TBucketName, 
+        filename: string, 
+        options: TReadFileOptions
+    ): Promise<Buffer>;
+
+    public abstract createReadStream( bucketName: TBucketName, filename: string );
+
+    public abstract exists( bucketName: TBucketName, filename: string ): Promise<boolean>;
+
+    public abstract move( bucketName: TBucketName, source: string, destination: string, options: { overwrite?: boolean }): Promise<void>;
+
+    public abstract outputFile( 
+        bucketName: TBucketName, 
+        filename: string, 
+        content: string | Buffer, 
+        options?: TOutputFileOptions 
+    ): Promise<{
+        path: string
+    }>;
+
+    public abstract readJSON( bucketName: TBucketName, filename: string ): Promise<any>;
+
+    public abstract delete( bucketName: TBucketName, filename: string ): Promise<boolean>;
+
+    public abstract deleteDir( bucketName: TBucketName, dirname: string ): Promise<boolean>;
+
+    public abstract unmount(): Promise<void>;
+
+}