5htp-core 0.6.2 → 0.6.3

package/server/services/prisma/index.ts

@@ -10,7 +10,7 @@ import type { Application } from '@server/app';
 import Service from '@server/app/service';
 
 // Specific
-import Facet, { TSubset } from './Facet';
+import Facet, { TDelegate, TSubset, Transform } from './Facet';
 
 /*----------------------------------
 - TYPES
@@ -52,13 +52,11 @@ export default class ModelsManager extends Service<Config, Hooks, Application> {
     }
 
     public Facet<
-        D extends {
-            findMany(args?: any): Promise<any>
-            findFirst(args?: any): Promise<any>
-        },
+        D extends TDelegate<R>,
         S extends TSubset,
-        R
-    >(...args: [D, S, R]) {
+        R,
+        RT
+    >(...args: [D, S, Transform<S, R, RT>]) {
 
         return new Facet(
             this.client,

package/server/services/router/http/multipart.ts

@@ -81,11 +81,16 @@ export const traiterMultipart = (...canaux: any[]) => {
                     && 
                     donnee.data instanceof Buffer
                 ){
+                    const md5 = donnee.md5;
+                    const data = donnee.data;
                     donnee = new File(donnee.data, donnee.name, { 
                         type: donnee.mimetype,
                         lastModified: Date.now(),
                         //size: donnee.size,
                     });
+
+                    donnee.md5 = md5;
+                    donnee.data = data;
                 }
                 
                 brancheA[ cle ] = donnee;

package/server/services/router/index.ts

@@ -55,7 +55,7 @@ export type { default as Request, UploadedFile } from "./request";
 export type { default as Response, TRouterContext } from "./response";
 export type { TRoute, TAnyRoute } from '@common/router';
 
-export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
+export type TApiRegisterArgs<TRouter extends TServerRouter> = ([
     path: string,
     controller: TServerController<TRouter>
 ] | [
@@ -64,7 +64,7 @@ export type TApiRegisterArgs<TRouter extends ServerRouter> = ([
     controller: TServerController<TRouter>
 ])
 
-export type TServerController<TRouter extends ServerRouter> = (context: TRouterContext<TRouter>) => any;
+export type TServerController<TRouter extends TServerRouter> = (context: TRouterContext<TRouter>) => any;
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS'
 export type TRouteHttpMethod = HttpMethod | '*';
@@ -83,8 +83,7 @@ export type HttpHeaders = { [cle: string]: string }
 const LogPrefix = '[router]';
 
 export type Config<
-    TServiceList extends TRouterServicesList = TRouterServicesList,
-    TAdditionnalSsrData extends {} = {}
+    TServices extends TRouterServicesList
 > = {
 
     debug: boolean,
@@ -96,18 +95,16 @@ export type Config<
     http: HttpServiceConfig,
 
     context: (
-        request: ServerRequest<ServerRouter>, 
+        request: ServerRequest<TServerRouter>, 
         app: Application
-    ) => TAdditionnalSsrData,
+    ) => {},
 
-    plugins: {
-        [routerServiceId: string]: RouterService
-    }
+    plugins: TServices
 }
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
 type TRouterServicesList = {
-    [serviceName: string]: RouterService<ServerRouter>
+    [serviceName: string]: RouterService
 }
 
 export type Hooks = {
@@ -117,14 +114,20 @@ export type Hooks = {
 export type TControllerDefinition = {
     path?: string,
     schema?: zod.ZodSchema,
-    controller: TServerController<ServerRouter>,
+    controller: TServerController<TServerRouter>,
 }
 
+export type TServerRouter = ServerRouter<Application, TRouterServicesList, Config<TRouterServicesList>>;
+
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
-export default class ServerRouter 
-    extends Service<Config, Hooks, Application> implements BaseRouter {
+export default class ServerRouter<
+    TApplication extends Application,
+    TServices extends TRouterServicesList,
+    TConfig extends Config<TServices>,
+>
+    extends Service<TConfig, Hooks, TApplication, TApplication> implements BaseRouter {
 
     public disks = this.use<DisksManager>('Core/Disks', { optional: true });
     
@@ -151,7 +154,7 @@ export default class ServerRouter
     - SERVICE
     ----------------------------------*/
 
-    public constructor( ...args: TServiceArgs<ServerRouter>) {
+    public constructor( ...args: TServiceArgs< ServerRouter<TApplication, TServices, TConfig> >) {
 
         super(...args);
 
@@ -165,14 +168,11 @@ export default class ServerRouter
 
     public async ready() {
 
-        // Every hours
-        setInterval(() => {
-            this.refreshStaticPages();
-        }, 1000 * 60 * 60);
-
         // Detect router services
         for (const serviceName in this.config.plugins) {
-            this.app.register( this.config.plugins[serviceName] )
+            const service = this.config.plugins[serviceName];
+            service.parent = this;
+            this.app.register( service )
         }
 
          // Use require to avoid circular references
@@ -211,6 +211,12 @@ export default class ServerRouter
             );
         };
 
+
+        // When all the services are ready, initialize static routes
+        this.app.on('ready', () => {
+            this.initStaticRoutes();
+        });
+
     }
 
     public async shutdown() {
@@ -233,6 +239,8 @@ export default class ServerRouter
 
         if (!rendered) {
 
+            console.log('[router] renderStatic: url', url);
+
             const fullUrl = this.url(url, {}, true);
             const response = await got( fullUrl, {
                 method: 'GET',
@@ -261,6 +269,26 @@ export default class ServerRouter
         
     }
 
+    private initStaticRoutes() {
+
+        for (const route of this.routes) {
+
+            if (!route.options.static)
+                continue;
+
+            // Add to static pages
+            // Should be a GET oage that don't take any parameter
+            for (const url of route.options.static.urls) {
+                this.renderStatic(url, route.options.static);
+            }
+        }
+
+        // Every hours, refresh static pages
+        setInterval(() => {
+            this.refreshStaticPages();
+        }, 1000 * 60 * 60);
+    }
+
     private refreshStaticPages() {
 
         console.log('[router] refreshStaticPages');
@@ -270,15 +298,10 @@ export default class ServerRouter
             if (page.expire && page.expire < Date.now()) {
 
                 this.renderStatic(pageUrl, page.options);
-
             }
         }
     }
 
-
-
-
-
     private registerRoutes(defModules: GlobImportedWithMetas<TRouteModule>) {
         for (const routeModule of defModules) {
 
@@ -327,14 +350,6 @@ export default class ServerRouter
 
         this.routes.push(route);
 
-        // Add to static pages
-        // Should be a GET oage that don't take any parameter
-        if (options.static) {
-            for (const url of options.static.urls) {
-                this.renderStatic(url, options.static);
-            }
-        }
-
         return this;
 
     }
@@ -370,10 +385,10 @@ export default class ServerRouter
             req: Request,
             res: Response,
             next: NextFunction,
-            requestContext: TRouterContext
+            requestContext: TRouterContext<this>
         ) => void
     ) {
-        return (context: TRouterContext) => new Promise((resolve) => {
+        return (context: TRouterContext<this>) => new Promise((resolve) => {
             
             context.request.res.on('finish', function() {
                 //console.log('the response has been sent', request.res.statusCode);

package/server/services/router/request/api.ts

@@ -31,18 +31,6 @@ export default class ApiClientRequest extends RequestService implements ApiClien
         throw new Error("api.fetch shouldn't be called here.");
     }
 
-    public get = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('GET', path, data, opts);
-
-    public post = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('POST', path, data, opts);
-
-    public put = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('PUT', path, data, opts);
-
-    public delete = <TData extends unknown = unknown>(path: string, data?: TObjetDonnees, opts?: TApiFetchOptions) => 
-        this.createFetcher<TData>('DELETE', path, data, opts);
-
     /*----------------------------------
     - PLACEHOLDERS
     ----------------------------------*/

package/server/services/router/request/validation/zod.ts

@@ -0,0 +1,180 @@
+import { InputError } from '@common/errors';
+import zod, { _ZodType } from 'zod';
+
+export type TRichTextValidatorOptions = {
+    attachements?: boolean
+}
+
+export const preprocessSchema = (schema: zod.ZodObject): zod.ZodObject => {
+
+    // Not working, data is {}
+    return schema;
+
+    if (!(schema instanceof zod.ZodObject))
+        return schema;
+
+    if (schema.withPreprocessing)
+        return schema;
+
+    const shape = schema.def.shape;
+    const newShape: Record<string, zod.ZodTypeAny> = {};
+
+    for (const key in shape) {
+
+        if (!['newEntity', 'email'].includes(key))
+            continue;
+
+        let current: zod.ZodTypeAny = shape[key];
+        while (current) {
+            
+            const origType = current.type;
+            const preprocessor = toPreprocess[origType];
+
+            if (origType === 'object') {
+                newShape[key] = preprocessSchema(current as zod.ZodObject);
+                break;
+            }
+
+            if (preprocessor) {
+                newShape[key] = preprocessor(current);
+                console.log('====newShape', key, newShape[key]);
+                break;
+            }
+
+            current = current.def;
+        }
+    }
+
+    const newSchema = zod.object(newShape);
+    newSchema.withPreprocessing = true;
+    return newSchema;
+}
+
+const toPreprocess = {
+
+    string: (zString: zod.ZodString) => zod.preprocess( val => {
+        return val === '' ? undefined : val;
+    }, zString),
+
+    int: (zInt: zod.ZodInt) => zod.preprocess( val => {
+        return typeof val === 'string' ? Number.parseInt(val) : val;
+    }, zInt),
+
+}
+
+export const schema = { 
+    ...zod,  
+
+    file: () => {
+
+        // Chaine = url ancien fichier = exclusion de la valeur pour conserver l'ancien fichier
+        // NOTE: Si la valeur est présente mais undefined, alors on supprimera le fichier
+        /*if (typeof val === 'string')
+            return true;*/
+
+        return zod.file();
+    },
+
+    choice: ( choices: string[] | { value: any, label: string }[] | _ZodType, options: { multiple?: boolean } = {} ) => {
+
+        const normalizeValue = (value: any) => typeof value === 'object' ? value.value : value;
+
+        const valueType: _ZodType = Array.isArray(choices) 
+            ? zod.enum( choices.map(normalizeValue) ) 
+            : zod.string();
+
+        const itemType = zod.union([
+
+            zod.object({ value: valueType, label: zod.string() }),
+
+            valueType
+
+        ]);
+
+        const type = options.multiple ? zod.array( itemType ) : itemType;
+        
+        return type.transform(v => {
+            if (options.multiple) {
+                return v.map(normalizeValue);
+            } else {
+                return normalizeValue(v);
+            }
+        });
+    },
+
+    richText: (opts: TRichTextValidatorOptions = {}) => schema.custom(val => {
+
+        if (typeof val !== 'string') {
+            console.error("Invalid rich text format.", val);
+            return false;
+        }
+
+        // We get a stringified json as input since the editor workds with JSON string
+        try {
+            val = JSON.parse(val);
+        } catch (error) {
+            console.error("Failed to parse rich text json:", error, val);
+            return false;//throw new InputError("Invalid rich text format.");
+        }
+
+        // Check that the root exists and has a valid type
+        if (!val || typeof val !== 'object' || typeof val.root !== 'object' || val.root.type !== 'root') {
+            console.error("Invalid rich text value (1).", val);
+            return false;//throw new InputError("Invalid rich text value (1).");
+        }
+
+        // Check if root has children array
+        if (!Array.isArray(val.root.children)) {
+            console.error("Invalid rich text value (2).", val);
+            return false;
+        }
+
+        // Validate each child node in root
+        for (const child of val.root.children) {
+            if (!validateLexicalNode(child, opts))
+                return false;
+        }
+
+        return true;
+    })
+}
+
+// Recursive function to validate each node
+function validateLexicalNode(node: any, opts: TRichTextValidatorOptions ) {
+
+    // Each node should be an object with a `type` property
+    if (typeof node !== 'object' || !node.type || typeof node.type !== 'string')
+        throw new InputError("Invalid rich text value (3).");
+
+    // Validate text nodes
+    if (node.type === 'text') {
+
+        if (typeof node.text !== 'string')
+            throw new InputError("Invalid rich text value (4).");
+
+        // Validate paragraph, heading, or other structural nodes that may contain children
+    } else if (['paragraph', 'heading', 'list', 'listitem'].includes(node.type)) {
+
+        if (!Array.isArray(node.children) || !node.children.every(children => validateLexicalNode(children, opts))) {
+            throw new InputError("Invalid rich text value (5).");
+        }
+
+        // Files upload
+    } else if (node.type === 'image') {
+
+        // Check if allowed
+        /*if (opts.attachements === undefined)
+            throw new InputError("Image attachments not allowed in this rich text field.");*/
+
+        // TODO: check mime
+
+
+        // Upload file
+
+
+    }
+
+    return true;
+}
+
+export type { default as z } from 'zod';

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

@@ -12,7 +12,7 @@ import express from 'express';
 
 // Core
 import { Application } from '@server/app';
-import type ServerRouter from '@server/services/router';
+import type { RouterService, default as ServerRouter, TServerRouter } from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
 import { TRoute, TAnyRoute, TDomainsList } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
@@ -38,10 +38,10 @@ export type TBasicSSrData = {
     domains: TDomainsList
 }
 
-export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
+export type TRouterContext<TRouter extends TServerRouter> = (
     // Request context
     {
-        app: Application,
+        app: TRouter["app"],
         context: TRouterContext<TRouter>, // = this
         request: ServerRequest<TRouter>,
         api: ServerRequest<TRouter>["api"],
@@ -52,14 +52,19 @@ export type TRouterContext<TRouter extends ServerRouter = ServerRouter> = (
 
         Router: TRouter,
     }
-    //& TRouterContextServices<TRouter>
+    & TRouterContextServices<TRouter>
 )
 
-export type TRouterContextServices<TRouter extends ServerRouter> = (
+export type TRouterContextServices< 
+    TRouter extends TServerRouter,
+    TPlugins = TRouter["config"]["plugins"]
+> = (
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
-        [serviceName in keyof TRouter["services"]]: ReturnType< TRouter["services"][serviceName]["requestService"] >
+        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends RouterService 
+            ? ReturnType<TPlugins[serviceName]["requestService"]> 
+            : TPlugins[serviceName]
     }
 )
 
@@ -212,7 +217,7 @@ export default class ServerResponse<
         return this;
     }
 
-    public async render( page: Page, context: TRouterContext, additionnalData: {} ) {
+    public async render( page: Page, context: TRouterContext<TRouter>, additionnalData: {} ) {
 
         // Set page in context for the client side
         context.page = page;
@@ -308,11 +313,11 @@ export default class ServerResponse<
         return this.end();
     }
 
-    public redirect(url: string, code: number = 302) {
+    public redirect(url: string, code: number = 302, absolute: boolean = false) {
 
         debug && console.log("[routeur][response] Redirect", url);
         this.statusCode = code;
-        this.headers['Location'] = this.router.url( url );
+        this.headers['Location'] = this.router.url( url, {}, absolute );
         return this.end();
     }
 

package/server/services/router/response/page/document.tsx

@@ -39,8 +39,9 @@ export default class DocumentRenderer<TRouter extends Router> {
                     <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1" />
 
                     {/* CSS */}
-                    <link rel="stylesheet" type="text/css" href="/public/icons.css" />
                     <link rel="preload" href="/public/client.css" as="style" />
+                    <link rel="preload" as="font" href={"/public/icons.woff2?v=" + BUILD_ID} type="font/woff2" />
+                    <link rel="stylesheet" type="text/css" href="/public/icons.css" />
                     <link rel="stylesheet" type="text/css" href="/public/client.css" />
                     <ColorSchemeScript />
 
@@ -120,6 +121,7 @@ export default class DocumentRenderer<TRouter extends Router> {
 
     private styles( page: Page ) {
         return <>
+            <link rel="preload" as="font" href={"/public/icons.woff2?v=" + BUILD_ID} type="font/woff2" />
             <link rel="stylesheet" type="text/css" href={"/public/icons.css?" + BUILD_ID} />
             <link rel="preload" href="/public/client.css" as="style" />
             <link rel="stylesheet" type="text/css" href="/public/client.css" />
@@ -135,8 +137,8 @@ export default class DocumentRenderer<TRouter extends Router> {
 
     private async scripts( response: ServerResponse<TRouter>, page: Page ) {
 
-        const context = safeStringify( response.forSsr(page) );
-
+        const ssrData = response.forSsr(page);
+        const context = safeStringify( ssrData );
         const routesForClient = JSON.stringify( this.router.ssrRoutes );
 
         return <>

package/server/services/router/service.ts

@@ -11,7 +11,10 @@ import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type RequestService from './request/service';
 
-export type TRouterServiceArgs = TServiceArgs<RouterService>;
+export type TRouterServiceArgs = [
+    getConfig: TServiceArgs<RouterService>[1],
+    app: Application,
+];
 
 /*----------------------------------
 - SERVICE
@@ -20,10 +23,10 @@ export default abstract class RouterService<
     TConfig extends {} = {}
 > extends Service<TConfig, {}, Application> {
 
-    public constructor( ...args: TRouterServiceArgs) {
-        super(...args);
+    public constructor( ...[config, app]: TRouterServiceArgs) {
+        super(app, config, app);
     }
 
-    public abstract requestService( request: ServerRequest<Router> ): RequestService | null;
+    public abstract requestService( request: ServerRequest<RouterService> ): RequestService | {} | null;
 
 }

package/server/services/schema/request.ts

@@ -2,15 +2,17 @@
 - DEPENDANCES
 ----------------------------------*/
 
+// Npm
+import zod from 'zod';
+import { SomeType } from 'zod/v4/core';
+ 
 // Core
 import { 
-    default as Router, RequestService, Request as ServerRequest
+    default as Router, TServerRouter, Request as ServerRequest
 } from '@server/services/router';
 
-import Schema, { TSchemaFields, TValidatedData } from '@server/services/router/request/validation/schema';
-
-// Specific
-import ServerSchemaValidator from '.';
+// Ap
+import { preprocessSchema, schema } from '@server/services/router/request/validation/zod';
 
 /*----------------------------------
 - SERVICE CONFIG
@@ -25,38 +27,23 @@ export type TConfig = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class RequestValidator extends ServerSchemaValidator implements RequestService {
-
-    public constructor(
-        public request: ServerRequest<Router>,
-        public config: TConfig,
-        public router = request.router,
-        public app = router.app
-    ) {
-
-        super(app);
-
-    }
-
-    public validate<TSchemaFieldsA extends TSchemaFields>( 
-        fields: TSchemaFieldsA | Schema<TSchemaFieldsA> 
-    ): TValidatedData<TSchemaFieldsA> {
+export default(
+    request: ServerRequest< TServerRouter >,
+    config: TConfig,
+    router = request.router,
+    app = router.app
+) => ({
 
-        this.config.debug && console.log(LogPrefix, "Validate request data:", this.request.data);
+    ...schema,
 
-        const schema = fields instanceof Schema ? fields : new Schema(fields);
+    validate( fields: zod.ZodSchema | { [key: string]: zod.ZodSchema } ) {
 
-        // Les InputError seront propagées vers le middleware dédié à la gestion des erreurs
-        const values = schema.validate( this.request.data, {
-            debug: this.config.debug,
-            validateDeps: false,
-            validators: this
-        }, []);
+        config.debug && console.log(LogPrefix, "Validate request data:", request.data);
 
-        // For logging
-        this.request.validatedData = values;
+        const schema = typeof fields === 'object' ? zod.object(fields) : fields;
 
-        return values;
-    }
+        const preprocessedSchema = preprocessSchema(schema);
 
-}
+        return preprocessedSchema.parse(request.data);
+    },
+})

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

@@ -8,7 +8,7 @@ import {
     RouterService
 } from '@server/services/router';
 
-import RequestValidator, { TConfig } from '../request';
+import makeRequestValidators from '../request';
 
 /*----------------------------------
 - TYPES
@@ -22,7 +22,7 @@ export default class SchemaRouterService<
     TUser extends {} = {}
 > extends RouterService {
 
-    public requestService( request: ServerRequest ): RequestValidator {
-        return new RequestValidator( request, this.config );
+    public requestService( request: ServerRequest ) {
+        return makeRequestValidators( request, this.config );
     }
 }

package/types/icons.d.ts

@@ -1 +1 @@
-export type TIcones = "solid/spinner-third"|"long-arrow-right"|"times-circle"|"brands/whatsapp"|"times"|"search"|"user"|"rocket"|"globe"|"bullhorn"|"briefcase"|"chart-line"|"handshake"|"ellipsis-h"|"brands/google"|"brands/reddit-alien"|"brands/linkedin-in"|"brands/github"|"robot"|"comments"|"user-friends"|"angle-down"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"info-circle"|"check-circle"|"exclamation-circle"|"bars"|"font"|"tag"|"compress"|"bolt"|"puzzle-piece"|"planet-ringed"|"chart-bar"|"power-off"|"heart"|"lock"|"eye"|"credit-card"|"at"|"brands/linkedin"|"key"|"database"|"solid/fire"|"usd-circle"|"lightbulb"|"solid/dollar-sign"|"download"|"code"|"solid/clock"|"exclamation"|"solid/download"|"seedling"|"palette"|"car"|"plane"|"university"|"hard-hat"|"graduation-cap"|"cogs"|"film"|"leaf"|"tshirt"|"utensils"|"map-marked-alt"|"dumbbell"|"stethoscope"|"concierge-bell"|"book"|"shield-alt"|"gavel"|"industry"|"square-root-alt"|"newspaper"|"pills"|"medal"|"capsules"|"balance-scale"|"home"|"praying-hands"|"shopping-cart"|"flask"|"futbol"|"microchip"|"satellite-dish"|"shipping-fast"|"passport"|"tools"|"user-circle"|"plus-circle"|"brands/twitter"|"brands/facebook"|"comment-alt"|"check"|"angle-left"|"angle-right"|"paper-plane"|"long-arrow-left"|"meh-rolling-eyes"|"arrow-left"|"arrow-right"|"trash"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"link"|"unlink"|"pen"|"file"|"plus"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"
+export type TIcones = "solid/spinner-third"|"rocket"|"user-circle"|"brands/linkedin"|"play"|"stop"|"trash"|"times"|"at"|"star"|"plus"|"minus"|"magnet"|"paper-plane"|"search"|"check"|"plus-circle"|"regular/shield-check"|"angle-down"|"clock"|"cog"|"ellipsis-h"|"long-arrow-right"|"lightbulb"|"long-arrow-left"|"phone"|"arrow-right"|"plane-departure"|"comments-alt"|"user-shield"|"shield-alt"|"chart-line"|"money-bill-wave"|"link"|"file-alt"|"solid/crown"|"eye"|"pen"|"file"|"envelope"|"angle-up"|"user-plus"|"sack-dollar"|"info-circle"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"download"|"brands/google"|"brands/whatsapp"|"crown"|"check-circle"|"exclamation-circle"|"times-circle"|"arrow-left"|"key"|"building"|"briefcase"|"map-marker-alt"|"graduation-cap"|"solid/check-circle"|"solid/exclamation-triangle"|"solid/times-circle"|"hourglass"|"angle-left"|"angle-right"|"broom"|"question-circle"|"coin"|"coins"|"plug"|"arrow-to-bottom"|"external-link"|"magic"|"minus-circle"|"user"|"meh-rolling-eyes"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"unlink"|"font"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"