5htp-core 0.4.6 → 0.4.7

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.4.6",
+	"version": "0.4.7",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",

package/src/client/assets/css/components/table.less

@@ -1,5 +1,6 @@
 .table {
     overflow: auto;
+    max-height: 90vh;
 
     > table {
         border-collapse: collapse;
@@ -13,7 +14,7 @@
     }
 
     &.card {
-        padding: 1em 0;
+        padding: 0;
     }
 }
 
@@ -26,7 +27,7 @@ table {
 
     // By default, chrome disables text inherits
     line-height: inherit;
-    font-size: inherit;
+    font-size: 0.9em;
 
     th {
         font-weight: 500;
@@ -38,8 +39,8 @@ table {
         padding: 1em 1em;
         text-align: left;
 
-        + td, th {
-            border-left: solid 1px #F5F5F5
+        &:not(:last-child) {
+            border-right: solid 1px #F5F5F5;
         }
 
         &:first-child {
@@ -50,6 +51,29 @@ table {
             padding-right: 2em;
             text-align: right;
         }
+
+        &.stickyColumn {
+            position: sticky;
+            background: var(--cBg);
+            white-space: break-spaces;
+            z-index: 1;
+
+            &:first-child {
+                left: 0;
+            }
+
+            &:last-child {
+                right: 0;
+            }
+        }
+    }
+
+    thead {
+        position: sticky;
+        top: 0;
+        background: var(--cBg);
+        white-space: break-spaces;
+        z-index: 5;
     }
 
     tbody {
@@ -57,11 +81,45 @@ table {
         td, th {
             vertical-align: middle;
             border-top: solid 1px var(--cLine);
+            position: relative;
+        }
+
+        // Rows: Crop when too long
+        td {
+
+            cursor: default;
+
+            &.extendable > .row {
+
+                max-width: 20em;
+                overflow: hidden;
+                justify-content: flex-start;
+
+                &::after {
+                    content: ' ';
+                    display: block;
+                    position: absolute;
+
+                    top: 0;
+                    right: 0;
+                    width: 30%;
+                    height: 100%;
+
+                    background: linear-gradient(to right, rgba(255, 255, 255, 0), var(--cBg));
+                }
+
+                > * {
+                    flex-shrink: 0;
+                }
+
+                > .badge {
+                    font-size: 0.8em;
+                }
+            }
         }
 
-        &.actuel td {
-            background: var(--cPrincipale);
-            color: #fff;
+        tr:hover > td {
+            background: #FAFAFA;
         }
     }
 
@@ -112,4 +170,9 @@ table {
             }
         }
     }*/
+}
+
+.modal .tableCellExtended .row {
+    flex-wrap: wrap;
+    justify-content: flex-start;
 }

package/src/client/components/Table/index.tsx

@@ -2,11 +2,13 @@
 /*----------------------------------
 - DEPENDANCES
 ----------------------------------*/
+
 // Libs
 import React from 'react';
-import { ComponentChild } from 'preact';
+import { JSX, ComponentChild } from 'preact';
 
 // Composants
+import useContext from '@/client/context';
 import Button, { Props as TButtonProps } from '@client/components/button';
 import Popover from '../containers/Popover';
 import Checkbox from '../inputv3/Checkbox';
@@ -21,6 +23,7 @@ export type Props<TRow> = {
     
     data: TRow[],
     columns: (row: TRow, rows: TRow[], index: number) => TColumn[];
+    stickyHeader?: boolean,
 
     setData?: (rows: TRow[]) => void,
     empty?: ComponentChild | false,
@@ -29,11 +32,11 @@ export type Props<TRow> = {
     actions?: TAction<TRow>[]
 }
 
-export type TColumn = {
+export type TColumn = JSX.HTMLAttributes<HTMLElement> & {
     label: ComponentChild,
     cell: ComponentChild,
     raw?: number | string | boolean,
-    class?: string
+    stick?: boolean,
 }
 
 export type TAction<TRow> = Omit<TButtonProps, 'onClick'> & {
@@ -47,13 +50,16 @@ export type TAction<TRow> = Omit<TButtonProps, 'onClick'> & {
 - COMPOSANTS
 ----------------------------------*/
 export default function Liste<TRow extends TDonneeInconnue>({
+    stickyHeader,
     data: rows, setData, empty,
     columns, actions, ...props
 }: Props<TRow>) {
 
+    const { modal } = useContext();
+
     if (rows.length === 0)
         return empty === false ? null : (
-            <div class="pd-2 col al-center">
+            <div class={"pd-2 col al-center " + (props.className || '')}>
                 {empty || <>
                     <i src="meh-rolling-eyes" class="xl" />
                     Uh ... No rows here.
@@ -92,29 +98,75 @@ export default function Liste<TRow extends TDonneeInconnue>({
                 </td>
             )}
 
-            {columns(row, rows, iDonnee).map((col) => {
+            {columns(row, rows, iDonnee).map(({ 
+                label, cell, class: className, raw, 
+                stick, width, ...cellProps 
+            }) => {
+
+                let classe = className || '';
+                if (typeof raw === 'number')
+                    classe += 'txtRight';
+
+                if (stick) {
+                    classe += ' stickyColumn';
+                }
+
+                if (width) {
+
+                    if (cellProps.style === undefined)
+                        cellProps.style = {};
+
+                    cellProps.style = {
+                        ...cellProps.style,
+                        minWidth: width,
+                        width: width,
+                        maxWidth: width,
+                    }
+                }
 
                 if (iDonnee === 0) renduColonnes.push(
-                    <th>
-                        {col.label}
+                    <th class={classe} {...cellProps}>
+                        {label}
                     </th>
                 );
 
-                const affichageBrut = ['number', 'string'].includes(typeof col.cell) || React.isValidElement(col.cell);
+                let render: ComponentChild;
+                if (Array.isArray(cell)) {
 
-                let classe = col.class || '';
-                if (typeof col.raw === 'number')
-                    classe += 'txtRight';
+                    classe += ' extendable';
+
+                    render = (
+                        <div class="row sp-05">
+                            {cell.map((item, i) => (
+                                <span class={"badge bg light" + ((i % 7) + 1)}>
+                                    {item}
+                                </span>
+                            ))}
+                        </div>
+                    )
+
+                    // Extension
+                    cellProps.onClick = () => modal.show(() => (
+                        <div class="card col tableCellExtended">
+                            <h3>{label}</h3>
+                            {render}
+                        </div>
+                    ));
+                    
+                } else if (['number', 'string'].includes(typeof cell) || React.isValidElement(cell)) {
+                    render = cell;
+                } else 
+                    render = JSON.stringify(cell);
 
                 return (
-                    <td class={classe}>
-                        {affichageBrut ? col.cell : JSON.stringify(col.cell)}
+                    <td class={classe} {...cellProps}>
+                        {render}
                     </td>
                 )
             })}
 
             {actions !== undefined && (
-                <td>
+                <td class="stickyColumn">
                     <Popover content={(
                         <ul class="col menu card bg white">
                             {actions.map(({ label, onClick, ...props }: TAction<TRow>) => (
@@ -148,7 +200,7 @@ export default function Liste<TRow extends TDonneeInconnue>({
     return <>
         <div {...props}>
             <table>
-                <thead>
+                <thead className={stickyHeader ? 'stickyHeader' : undefined}>
                     <tr>
                         {selectionMultiple && (
                             <th>

package/src/common/router/request/index.ts

@@ -5,6 +5,9 @@
 // Core
 import Response from '../response';
 
+// Types
+import type { TBasicUser } from '@server/services/auth';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -22,7 +25,7 @@ export default abstract class BaseRequest {
 
     public data: TObjetDonnees = {};
     public abstract response?: Response;
-    public user: User | null = null;
+    public user: TBasicUser | null = null;
 
     public constructor(
         public path: string,

package/src/common/validation/validators.ts

@@ -41,6 +41,34 @@ type TSubtype = TSchemaSubtype | Validator<any>;
 ----------------------------------*/
 export default class SchemaValidators {
 
+    /*----------------------------------
+    - UTILITIES
+    ----------------------------------*/
+    // Make every field optional
+    public partial = <TFields extends TSchemaFields>(schema: TFields, fieldsList?: (keyof TFields)[] ) => {
+
+        if (fieldsList === undefined)
+            fieldsList = Object.keys(schema) as (keyof TFields)[];
+
+        const partialSchema: Partial<TFields> = {};
+        for (const key of fieldsList) {
+
+            if (!(key in schema))
+                throw new Error("The field " + key + " is not in the schema.");
+
+            // Only if validator
+            if (schema[key] instanceof Validator)
+                partialSchema[key] = new Validator(schema[key].type, schema[key].validateType, {
+                    ...schema[key].options,
+                    opt: true
+                });
+            else
+                partialSchema[key] = schema[key];
+        }
+
+        return partialSchema as TFields;
+    }
+
     /*----------------------------------
     - CONTENEURS
     ----------------------------------*/

package/src/server/app/index.ts

@@ -37,17 +37,6 @@ type Hooks = {
     }
 }
 
-declare global {
-
-    //interface Services { }    
-
-    interface AppHooks {
-       
-    }
-
-    interface User { }
-}
-
 export const Service = ServicesContainer;
 
 /*----------------------------------

package/src/server/services/auth/index.ts

@@ -62,13 +62,24 @@ export type TServices = {
 
 }
 
+export type TBasicUser = {
+    type: string,
+    name: string,
+    roles: string[]
+}
+
+export type TBasicJwtSession = {
+    accountType: string,
+    apiKey?: string
+}
+
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default abstract class AuthService<
-    TUser extends {},
+    TUser extends TBasicUser,
     TApplication extends Application,
-    TJwtSession extends {} = {},
+    TJwtSession extends TBasicJwtSession = TBasicJwtSession,
     TRequest extends ServerRequest<Router> = ServerRequest<Router>,
 > extends Service<TConfig, THooks, TApplication, TServices> {
 
@@ -95,51 +106,37 @@ export default abstract class AuthService<
     public abstract login( ...args: any[] ): Promise<{ user: TUser, token: string }>;
     public abstract decodeSession( jwt: TJwtSession, req: THttpRequest ): Promise<TUser | null>;
 
-    protected abstract displayName(user?: TUser | null): string;
     protected abstract displaySessionName(session: TJwtSession): string;
 
+    // https://beeceptor.com/docs/concepts/authorization-header/#examples
     public async decode( req: THttpRequest, withData: true ): Promise<TUser | null>;
     public async decode( req: THttpRequest, withData?: false ): Promise<TJwtSession | null>;
     public async decode( req: THttpRequest, withData: boolean = false ): Promise<TJwtSession | TUser | null> {
 
         this.config.debug && console.log(LogPrefix, 'Decode:', { cookie: req.cookies['authorization'] });
         
-        let token: string | undefined;
-        if (('cookies' in req) && typeof req.cookies['authorization'] === 'string')
-            token = req.cookies['authorization'];
-        // Desktop app webview do not support cookie config, so wwe retrieve it from headers
-        else if (typeof req.headers['authorization'] === 'string')
-            token = req.headers['authorization'];
+        // Get auth token
+        const authMethod = this.getAuthMethod(req);
+        if (authMethod === null)
+            return null;
+        const { tokenType, token } = authMethod;
 
-        if (token === undefined)
-            return this.unauthorized(req);
-
-        let session: TJwtSession;
-        try {
-            session = jwt.verify(token, this.config.jwt.key, { 
-                maxAge: this.config.jwt.expiration 
-            });
-        } catch (error) {
-            console.warn(LogPrefix, "Failed to decode jwt token:", token);
-            return this.unauthorized(req);
-        }
+        // Get auth session
+        const session = this.getAuthSession(tokenType, token);
 
         // Return email only
-        const sessionName = this.displaySessionName(session);
         if (!withData) {
-            this.config.debug && console.log(LogPrefix, `Auth user ${sessionName} successfull. Return email only`);
+            this.config.debug && console.log(LogPrefix, `Auth user successfull. Return email only`);
             return session;
         }
 
         // Deserialize full user data
-        this.config.debug && console.log(LogPrefix, `Deserialize user ${sessionName}`);
+        this.config.debug && console.log(LogPrefix, `Deserialize user`, session);
         const user = await this.decodeSession(session, req);
-        
-        // User not found
         if (user === null)
             return null;
 
-        this.config.debug && console.log(LogPrefix, `Deserialized user ${sessionName}:`, this.displayName(user));
+        this.config.debug && console.log(LogPrefix, `Deserialized user:`, user.name);
 
         return {
             ...user,
@@ -147,15 +144,55 @@ export default abstract class AuthService<
         };    
     }
 
-    public unauthorized( req: THttpRequest ) {
+    private getAuthMethod( req: THttpRequest ): null | { token: string, tokenType?: string } {
 
-        if ('res' in req) {
-            // If use auth failed, we remove the jwt token so we avoid to trigger the same auth error in the next request
-            console.warn(LogPrefix, "Auth failed: remove authorization cookie");
-            req.res?.clearCookie('authorization');
-        }
+        let token: string | undefined;
+        let tokenType: string | undefined;
+        if (typeof req.headers['authorization'] === 'string') {
+
+            ([ tokenType, token ] = req.headers['authorization'].split(' '));
 
-        return null;
+        } else if (('cookies' in req) && typeof req.cookies['authorization'] === 'string') {
+
+            token = req.cookies['authorization'];
+            tokenType = 'Bearer';
+
+        } else 
+            return null;
+
+        if (token === undefined)
+            return null;
+
+        return { tokenType, token };
+    }
+
+    private getAuthSession( tokenType: string | undefined, token: string ): TJwtSession {
+
+        let session: TJwtSession;
+
+        // API Key
+        if (tokenType === 'Apikey') {
+
+            const [accountType] = token.split('-');
+
+            this.config.debug && console.log(LogPrefix, `Auth via API Key`, token);
+            session = { accountType, apiKey: token } as TJwtSession;
+
+        // JWT
+        } else if (tokenType === 'Bearer') {
+            this.config.debug && console.log(LogPrefix, `Auth via JWT token`, token);
+            try {
+                session = jwt.verify(token, this.config.jwt.key, { 
+                    maxAge: this.config.jwt.expiration 
+                });
+            } catch (error) {
+                console.warn(LogPrefix, "Failed to decode jwt token:", token);
+                throw new Forbidden(`The JWT token provided in the Authorization header is invalid`);
+            }
+        } else 
+            throw new InputError(`The authorization scheme provided in the Authorization header is unsupported.`);
+
+        return session;
     }
 
     public createSession( session: TJwtSession, request: TRequest ): string {
@@ -176,27 +213,24 @@ export default abstract class AuthService<
         const user = request.user;
         if (!user) return;
 
-        this.config.debug && console.info(LogPrefix, `Logout ${this.displayName(user)}`);
+        this.config.debug && console.info(LogPrefix, `Logout ${user.name}`);
         request.res.clearCookie('authorization');
     }
 
-    public check( request: TRequest, role: TUserRole, motivation?: string): TUser;
-    public check( request: TRequest, role: false, motivation?: string): null;
-    public check( request: TRequest, role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
+    public check( request: TRequest, entity: string, role: TUserRole, motivation?: string): TUser;
+    public check( request: TRequest, entity: string, role: false, motivation?: string): null;
+    public check( request: TRequest, entity: string, role: TUserRole | false = 'USER', motivation?: string): TUser | null {
 
         const user = request.user;
 
-        this.config.debug && console.warn(LogPrefix, `Check auth, role = ${role}. Current user =`, this.displayName(user));
+        this.config.debug && console.warn(LogPrefix, `Check auth, role = ${role}. Current user =`, user?.name);
+
+        console.log({ entity, role, motivation });
 
         if (user === undefined) {
 
             throw new Error(`request.user has not been decoded.`);
 
-        // Shortcut: { auth: true } <=> { auth: 'USER' }
-        } else if (role === true) {
-
-            role = 'USER';
-
         // No auth needed
         } else if (role === false) {
 
@@ -206,18 +240,23 @@ export default abstract class AuthService<
         } else if (user === null) {
 
             this.config.debug && console.warn(LogPrefix, "Refusé pour anonyme (" + request.ip + ")");
-            throw new AuthRequired(motivation);
+            throw new AuthRequired('Please login to continue');
+
+        } else if (user.type !== entity) {
+
+            this.config.debug && console.warn(LogPrefix, `User type mismatch: ${user.type} (user) vs ${entity} (expected) (${request.ip})`);
+            throw new AuthRequired("Your account type doesn't have access to the requested content.");
             
         // Insufficient permissions
         } else if (!user.roles.includes(role)) {
 
-            console.warn(LogPrefix, "Refusé: " + role + " pour " + this.displayName(user) + " (" + (user.roles ? user.roles.join(', ') : 'role inconnu') + ")");
+            console.warn(LogPrefix, "Refusé: " + role + " pour " + user.name + " (" + (user.roles ? user.roles.join(', ') : 'role inconnu') + ")");
 
             throw new Forbidden("You do not have sufficient permissions to access this resource.");
 
         } else {
 
-            console.warn(LogPrefix, "Autorisé " + role + " pour " + this.displayName(user) + " (" + user.roles.join(', ') + ")");
+            console.warn(LogPrefix, "Autorisé " + role + " pour " + user.name + " (" + user.roles.join(', ') + ")");
 
         }
 

package/src/server/services/auth/router/request.ts

@@ -14,6 +14,9 @@ import { InputError, AuthRequired, Forbidden } from '@common/errors';
 import type AuthenticationRouterService from '.';
 import type { default as UsersManagementService, TUserRole } from '..';
 
+// Types
+import type { TBasicUser } from '@server/services/auth';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -22,7 +25,7 @@ import type { default as UsersManagementService, TUserRole } from '..';
 - MODULE
 ----------------------------------*/
 export default class UsersRequestService<
-    TUser extends {}
+    TUser extends TBasicUser
 > extends RequestService {
 
     public constructor( 
@@ -41,9 +44,10 @@ export default class UsersRequestService<
         return this.users.logout( this.request );
     }
 
-    public check( role: TUserRole, motivation?: string): TUser;
-    public check( role: false, motivation?: string): null;
-    public check( role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
-        return this.users.check( this.request, role, motivation );
+    // TODO: return user type according to entity
+    public check( entity: string, role: TUserRole, motivation?: string): TUser;
+    public check( entity: string, role: false, motivation?: string): null;
+    public check( entity: string, role: TUserRole | boolean = 'USER', motivation?: string): TUser | null {
+        return this.users.check( this.request, entity, role, motivation );
     }
 }

package/src/server/services/database/index.ts

@@ -551,7 +551,7 @@ export default class SQL extends Service<Config, Hooks, Application, Services> {
         if (updateAll) {
             for (const record of data)
                 for (const key in record)
-                    if (!valuesNamesToUpdate.includes( key ))
+                    if (!valuesNamesToUpdate.includes( key ) && (key in table.colonnes))
                         valuesNamesToUpdate.push( key );
         }
 

package/src/server/services/database/metas.ts

@@ -369,7 +369,7 @@ export default class MySQLMetasParser {
         // Given that this file is updated during run time, 
         // We output a typescript ambient file, so the file change doest trigger infinite app reload
         fs.outputFileSync( 
-            path.join( Container.path.server.generated, 'models.d.ts'), 
+            path.join( Container.path.server.generated, 'models.ts'), 
             types.join('\n') 
         );
     }

package/src/server/services/router/index.ts

@@ -62,7 +62,7 @@ export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
 
 export type TServerController<TRouter extends ServerRouter> = (context: TRouterContext<TRouter>) => any;
 
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'OPTIONS'
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 export type TRouteHttpMethod = HttpMethod | '*';
 
 export type TApiResponseData = {
@@ -264,6 +264,7 @@ export default class ServerRouter<
     public get = (...args: TApiRegisterArgs<this>) => this.registerApi('GET', ...args);
     public post = (...args: TApiRegisterArgs<this>) => this.registerApi('POST', ...args);
     public put = (...args: TApiRegisterArgs<this>) => this.registerApi('PUT', ...args);
+    public patch = (...args: TApiRegisterArgs<this>) => this.registerApi('PATCH', ...args);
     public delete = (...args: TApiRegisterArgs<this>) => this.registerApi('DELETE', ...args)
 
     protected registerApi(method: TRouteHttpMethod, ...args: TApiRegisterArgs<this>): this {

package/src/server/services/router/response/index.ts

@@ -22,6 +22,9 @@ import Page from './page';
 // To move into a new npm module: json-mask
 import jsonMask from './mask';
 
+// Types
+import type { TBasicUser } from '@server/services/auth';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -31,7 +34,7 @@ const debug = true;
 export type TBasicSSrData = {
     request: { data: TObjetDonnees, id: string },
     page: { chunkId: string, data?: TObjetDonnees },
-    user: User | null,
+    user: TBasicUser | null,
     domains: TDomainsList
 }
 
@@ -45,7 +48,7 @@ export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
         response: ServerResponse<TRouter>,
         route: TRoute,
         page?: Page,
-        user: User,
+        user: TBasicUser,
 
         Router: TRouter,
     }