proteum 1.0.2 → 2.0.0

package/server/services/auth/old.ts

@@ -1,277 +0,0 @@
-
-import md5 from 'md5';
-import { OAuth2Client, LoginTicket } from 'google-auth-library';
-
-
-
-type AuthResponse = {
-    token: string,
-    redirect: string,   
-    user: User
-}
-
-export default class {
-
-
-    protected async ready() {
-
-        // Google auth client
-        if (this.config.google) {
-
-            const httpConfig = this.app.http.publicUrl;
-
-            this.googleClient = new OAuth2Client(
-                this.config.google.web.clientId, // Google Client ID
-                this.config.google.web.secret, // Private key
-                httpConfig + "/auth/google/response" // Redirect url
-            );
-        }
-    }
-
-    
-    private googleClient: OAuth2Client | undefined;
-
-    public async FromGoogle(request: ServerRequest): Promise<string> {
-
-        if (!this.googleClient)
-            throw new Forbidden(`Authentication method disabled.`);
-
-        // Register  start time, so we can determine the signup time to display
-        request.response?.cookie('signupstart', Date.now());
-
-        // Google auth doesn't support local env
-        // So we simulate that  google sent a response with the user email
-        if (app.env.name === 'local') {
-            const { redirect } =  await this.Auth("tbsoftwares23@gmail.com", request, true);
-            return redirect;
-        }
-
-        return this.googleClient.generateAuthUrl({
-            access_type: 'offline',
-            scope: [
-                "email", "profile"
-            ]
-        });
-
-    }
-
-    public async GoogleResponse(
-        type: 'code' | 'token',
-        codeOrToken: string | undefined,
-        request: ServerRequest,
-    ): Promise<AuthResponse> {
-
-        const googleConfig = this.config.google;
-        if (!this.googleClient || !googleConfig)
-            throw new Forbidden(`Authentication method disabled.`);
-
-        if (codeOrToken === undefined)
-            throw new Forbidden("Bad code / token");
-
-        if (type === 'code') {
-            const r = await this.googleClient.getToken(codeOrToken);
-            return this.GoogleResponse('token', r.tokens.id_token, request);
-        }
-
-        this.config.debug && console.log(LogPrefix, "Auth via google", googleConfig);
-
-        let ticket: LoginTicket;
-        try {
-            ticket = await this.googleClient.verifyIdToken({
-                idToken: codeOrToken,
-                audience: [
-                    googleConfig.web.clientId,
-                    googleConfig.android.clientId,
-                ]
-            });
-        } catch (error) {
-            throw new Forbidden(`Google denied your login attempt: ` + error.message + `. If you don't think it's normal, please contact us.`);
-        }
-
-        const payload = ticket.getPayload();
-        if (payload === undefined)
-            throw new Forbidden("Invalid payload");
-        const { email, sub: google_id } = payload;
-
-        if (email === undefined)
-            throw new Forbidden("Unable to get your email address from the Google sign-in.");
-
-        return await this.Auth(email, request, true);
-
-    }
-
-    /**
-     * Login u
-     * @param email Email that identifies the account to log in
-     * @param request Used to call security-related features
-     * @param canPass true when from 3rd party auth, we're sure the email is owned bu the current user
-     * @param userInfo User field to update (eg: lastLogin)
-     * @returns 
-     */
-    public async Auth( 
-        email: string, 
-        request: ServerRequest, 
-        canPass: boolean = false,
-        userInfo: Partial<User> = {} 
-    ): Promise<AuthResponse> {
-
-        let user = await this.getData('email = ' + this.sql.esc(email));
-        let ip: IP;
-        let redirect: string;
-        if (!user) { // Signup
-
-            ip = await request.detect.botsAndMultiaccount();
-
-            // Create user
-            ({ user, redirect } = await this.Signup(email, request));
-
-        } else if (!canPass) { // Send login email
-
-            throw new Forbidden("This option is not available");
-
-            // If the current IP was used to connect to another account that the current
-            ip = await request.detect.botsAndMultiaccount(user.email);
-
-            // Send email with link to /auth/token (expiration 5 min)
-
-            // Route /auth/:token: check si même ip, même device
-
-        } else { // Login 
-
-            redirect = config.logoutUrl;
-            
-        }
-
-        /*await this.sql`
-            INSERT INTO UserLogin SET
-                user = ${user.email},
-                date = NOW(),
-                ip = ${request.ip},
-                device = ${request.deviceString()}
-        `.run();*/
-
-        const token = request.auth.login(user.email);
-
-        return { token, user, redirect };
-
-    }
-
-    public async Signup(email: string, request: ServerRequest, moreInfos: Partial<User> = {}) {
-
-        let username = email.split('@')[0];
-
-        // Prefix username if alreasy existing
-        const duplicates = await this.sql`
-            FROM User 
-            WHERE name REGEXP CONCAT('^', ${username}, '[0-9]*$');
-        `.count();
-
-        if (duplicates !== 0)
-            username += duplicates;
-
-        const user: Partial<User> = {
-            email,
-            emailHash: md5(email),
-            name: username,
-            referrer: request.cookies.r,
-            utm: request.cookies.utm,
-            ...moreInfos
-        }
-
-        // Hook
-        if (this.beforeSignup !== undefined)
-            await this.beforeSignup( user );
-            
-        // Referrer
-        if (user.referrer !== undefined) {
-
-            const refExists = await this.sql`FROM User WHERE name = ${user.referrer}`.exists();
-            if (!refExists)
-                user.referrer = undefined;
-            else {
-                
-                await this.sql.upsert('UserStats', { 
-                    user: user.referrer,
-                    date: new Date,
-                    refSignups: 1 
-                }, ['refSignups'], {
-                    upsertMode: 'increment'
-                });
-            }
-        }
-            
-        // Create user
-        await this.sql.insert('User', user);
-        await this.sql.update('logs.IP', { user_name: username }, { address: request.ip });
-
-        // Hook
-        let redirect: string = '/';
-        if (this.afterSignup !== undefined)
-            ({ redirect } = await this.afterSignup(user));
-
-        // TODO: download user avatar from gravatar
-        // remove user.emailHash
-
-        // Notif email
-        await this.email.send({
-            to: app.identity.author.email,
-            subject: app.identity.name + ": New User",
-            html: JSON.stringify(user)
-        });
-
-        // TODO
-        // this.hook.signup(user);
-        //Achievements.activity(user, 'just signed up', null);
-
-        // Instanciation
-        return { user, redirect };
-
-    }
-
-    public async setReferrer( referrer: unknown, { user, response, cookies, req, detect, request }: ServerRequest) {
-
-        if (!response || user)
-            return;
-
-        // Source tracking
-        if (!cookies.utm) {
-
-            const data = req.query;
-
-            const utm = [data.utm_medium, data.utm_source, data.utm_campaign]
-                .filter(a => a !== undefined);
-
-            response.cookie('utm', utm.join(','));
-        }
-
-        // Referral program
-        if (cookies.r === undefined && typeof referrer === "string") {
-
-            const conflict = await detect.conflictOfInterest( referrer, request );
-            if (conflict)
-                return;
-
-            // Check if user exists
-            const referrerExists = await this.sql`FROM User WHERE name = ${referrer}`.count();
-            if (referrerExists === 0)
-                return;
-
-            // await secutity.detectCheatAttempts();
-            // => Check IP (reprendre code existant)
-            // => Check si IP pas déjà utilisée par un autre membre (1 compte par IP)
-
-            // Tracking cookie for signup
-            response.cookie('r', referrer);
-
-            // Count the clic 
-            await this.sql.upsert('UserStats', { 
-                user: referrer,
-                date: new Date,
-                refClics: 1 
-            }, ['refClics'], {
-                upsertMode: 'increment'
-            });
-        }
-
-    }
-}

package/server/services/cache/commands.ts

@@ -1,41 +0,0 @@
-/*----------------------------------
-- 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

@@ -1,297 +0,0 @@
-/*----------------------------------
-- 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

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