@qelos/plugin-play 3.0.1 → 3.0.3

package/create-cert.js

@@ -1,6 +1,6 @@
 const {execSync} = require('child_process');
 
-execSync(`cd cert && docker run -v $PWD:/certs \\
+execSync(`cd cert && docker run -v ${process.cwd()}:/certs \\
   -e SSL_SUBJECT=${process.env.HOSTNAME || '0.0.0.0'} stakater/ssl-certs-generator:1.0`, {stdio: 'inherit'});
 
 console.log('done.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qelos/plugin-play",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Play a plugin for Qelos!",
   "main": "./dist/index.js",
   "scripts": {
@@ -19,7 +19,7 @@
     "@fastify/cookie": "^8.3.0",
     "@fastify/static": "^6.5.0",
     "@qelos/sdk": "^3.0.1",
-    "@qelos/web-sdk": "^3.0.1",
+    "@qelos/web-sdk": "^3.0.3",
     "fastify": "^4.3.0",
     "jsonwebtoken": "^8.5.1",
     "undici": "^5.8.0"

package/src/authentication.ts

@@ -260,19 +260,53 @@ export function getCallbackRoute(): RouteOptions {
 }
 
 export function getFrontendAuthorizationRoute(): RouteOptions {
+  let standaloneAuthorize: (reply) => Promise<any> = async () => {
+    return;
+  }
   if (config.qelosUrl) {
-    onFrontendAuthorization(async ({returnUrl, user, tenant}, request) => {
-      const draft = await getSdk().drafts.getDraft(returnUrl, `${tenant.sub}.${user.email}`);
-      if (draft && draft.contextData) {
-        return {
-          code: draft.contextData.code,
-          token: jwt.sign({code: draft.contextData, user, tenant}, config.accessTokenSecret, {expiresIn: '30min'}),
+    onFrontendAuthorization(async ({returnUrl, user, tenant}) => {
+      try {
+        const draft = await getSdk().drafts.getDraft(returnUrl, `${tenant.sub}.${user.email}`);
+        if (draft && draft.contextData) {
+          return {
+            code: draft.contextData.code,
+            token: jwt.sign({code: draft.contextData, user, tenant}, config.accessTokenSecret, {expiresIn: '30min'}),
+          }
         }
+      } catch {
+        //
       }
       return;
     });
+
+    if (config.dev) {
+      standaloneAuthorize = async (reply) => {
+        const [fullUser] = await getSdk().users.getList({exact: true, email: config.qelosUsername});
+        const user = {
+          _id: fullUser._id,
+          email: fullUser.email,
+          firstName: fullUser.firstName,
+          lastName: fullUser.lastName,
+          roles: fullUser.roles
+        }
+        const tenant = {
+          sub: user._id,
+          identifier: user.email
+        };
+        reply.setCookie('token_default', jwt.sign({
+          code: 'default',
+          user,
+          tenant
+        }, config.accessTokenSecret, {expiresIn: '30min'}));
+        return {
+          user,
+          tenant
+        };
+      }
+    }
   }
 
+
   return {
     method: 'POST',
     url: manifest.authorizeUrl,
@@ -298,8 +332,12 @@ export function getFrontendAuthorizationRoute(): RouteOptions {
           }
         }
       }
-      reply.statusCode = 401;
-      return notAuthorized;
+      const response = await standaloneAuthorize(reply);
+      if (!response) {
+        reply.statusCode = 401;
+        return notAuthorized;
+      }
+      return response;
     }
   }
 }

package/src/endpoints.ts

@@ -2,7 +2,7 @@ import {RouteOptions} from 'fastify/types/route';
 import {join} from 'path';
 import manifest from './manifest';
 
-interface QelosRouteParams extends RouteOptions {
+export interface QelosRouteParams extends RouteOptions {
   verifyToken: boolean;
 }
 

package/src/micro-frontends.ts

@@ -1,9 +1,25 @@
 import manifest, {NavBarGroup} from './manifest';
+import {addProxyEndpoint, QelosRouteParams} from './endpoints';
 
-export interface MicroFrontend {
+export interface IframeMicroFrontend extends GlobalMicroFrontend {
+  url: string;
+}
+
+export interface PreDesignedMicroFrontendOptions
+  extends Pick<QelosRouteParams, 'verifyToken'>,
+    Partial<Pick<QelosRouteParams, 'handler'>>,
+    GlobalMicroFrontend {
+  use: string;
+  fetchUrl?: string;
+}
+
+interface PreDesignedMicroFrontend extends Omit<PreDesignedMicroFrontendOptions, 'handler' | 'verifyToken'> {
+  fetchUrl: string;
+}
+
+export interface GlobalMicroFrontend {
   name: string;
   description: string;
-  url: string;
   roles?: string[],
   route?: {
     name: string;
@@ -24,11 +40,38 @@ export interface MicroFrontend {
   }
 }
 
-export function addMicroFrontend(mfe: MicroFrontend) {
-  manifest.microFrontends.push(mfe);
+export type MicroFrontendOptions = IframeMicroFrontend | PreDesignedMicroFrontendOptions
+export type MicroFrontend = IframeMicroFrontend | PreDesignedMicroFrontend
+
+export function addMicroFrontend(mfe: MicroFrontendOptions) {
+  mfe = {...mfe}
+  let manifestMfe: MicroFrontend;
+  if ('use' in mfe) {
+    const verifyToken = mfe.verifyToken || true;
+    delete mfe.verifyToken;
+
+    if ('handler' in mfe) {
+      const fetchUrl = mfe.fetchUrl || btoa(mfe.name);
+      const handler = mfe.handler;
+      delete mfe.handler;
+      addProxyEndpoint(fetchUrl, {
+        handler,
+        verifyToken,
+      });
+      manifestMfe = {
+        ...mfe as PreDesignedMicroFrontend,
+        fetchUrl
+      }
+    } else if ('fetchUrl' in mfe) {
+      manifestMfe = mfe as PreDesignedMicroFrontend;
+    }
+  } else {
+    manifestMfe = mfe;
+  }
+  manifest.microFrontends.push(manifestMfe);
 }
 
-export function addGroupedMicroFrontends(group: NavBarGroup, mfeArray: MicroFrontend[]) {
+export function addGroupedMicroFrontends(group: NavBarGroup, mfeArray: MicroFrontendOptions[]) {
   manifest.navBarGroups.push(group);
   mfeArray.forEach(mfe => {
     addMicroFrontend({...mfe, route: {...mfe.route, group: group.key}})