quidproquo-dev-server 0.0.237 → 0.0.239

package/lib/esm/actionProcessor/core/queue/index.js

@@ -0,0 +1,4 @@
+import { getQueueSendMessagesActionProcessor } from './getQueueSendMessageActionProcessor';
+export const getQueueActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getQueueSendMessagesActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/index.d.ts

@@ -1 +1,4 @@
-export * from './graphDatabaseOverride';
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export * from './core';
+export * from './webserver';
+export declare const getDevServerActionProcessors: ActionProcessorListResolver;

package/lib/esm/actionProcessor/index.js

@@ -1 +1,18 @@
-export * from './graphDatabaseOverride';
+import { getAwsActionProcessors } from 'quidproquo-actionprocessor-awslambda';
+import { getCustomActionActionProcessor } from 'quidproquo-actionprocessor-node';
+import { getCoreActionProcessor } from './core';
+import { getWebserverActionProcessor } from './webserver';
+export * from './core';
+export * from './webserver';
+export const getDevServerActionProcessors = async (qpqConfig, dynamicModuleLoader) => {
+    const storyActionProcessor = {
+        // Start with all the aws action processors..
+        ...(await getAwsActionProcessors(qpqConfig, dynamicModuleLoader)),
+        // Override with custom ones
+        ...(await getCoreActionProcessor(qpqConfig, dynamicModuleLoader)),
+        ...(await getWebserverActionProcessor(qpqConfig, dynamicModuleLoader)),
+        // Always done last, so they can ovveride the default ones if the user wants.
+        ...(await getCustomActionActionProcessor(qpqConfig, dynamicModuleLoader)),
+    };
+    return storyActionProcessor;
+};

package/lib/esm/actionProcessor/webserver/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getWebserverActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/webserver/index.js

@@ -0,0 +1,4 @@
+import { getServiceFunctionActionProcessor } from './serviceFunctionOverride';
+export const getWebserverActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getServiceFunctionActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/webserver/serviceFunctionOverride/getServiceFunctionExecuteActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getServiceFunctionExecuteActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/webserver/serviceFunctionOverride/getServiceFunctionExecuteActionProcessor.js

@@ -0,0 +1,29 @@
+import { actionResult, actionResultError, } from 'quidproquo-core';
+import { ServiceFunctionActionType } from 'quidproquo-webserver';
+import { eventBus } from '../../../logic/eventBus';
+const getProcessExecute = (qpqConfig, dynamicModuleLoader) => {
+    return async ({ functionName, service, payload, context, isAsync }, session) => {
+        const serviceFunctionEvent = {
+            functionName: functionName,
+            serviceName: service,
+            payload: payload,
+            storySession: {
+                ...session,
+                context,
+            },
+        };
+        const eventPromise = eventBus.publishAndWaitForResponse(ServiceFunctionActionType.Execute, serviceFunctionEvent);
+        if (isAsync) {
+            return actionResult(void 0);
+        }
+        const response = await eventPromise;
+        if (response.error) {
+            return actionResultError(response.error.errorType, response.error.errorText, response.error.errorStack);
+        }
+        console.log('Result', response.result);
+        return actionResult(response.result);
+    };
+};
+export const getServiceFunctionExecuteActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    [ServiceFunctionActionType.Execute]: getProcessExecute(qpqConfig, dynamicModuleLoader),
+});

package/lib/esm/actionProcessor/webserver/serviceFunctionOverride/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getServiceFunctionActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/webserver/serviceFunctionOverride/index.js

@@ -0,0 +1,4 @@
+import { getServiceFunctionExecuteActionProcessor } from './getServiceFunctionExecuteActionProcessor';
+export const getServiceFunctionActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getServiceFunctionExecuteActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/implementations/apiImplementation.d.ts

@@ -0,0 +1,2 @@
+import { DevServerConfig } from '../types';
+export declare const apiImplementation: (devServerConfig: DevServerConfig) => Promise<void>;

package/lib/esm/implementations/apiImplementation.js

@@ -0,0 +1,129 @@
+import { askProcessEvent, qpqCoreUtils, qpqExecuteLog, QpqRuntimeType } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import bodyParser from 'body-parser';
+import express from 'express';
+import multer from 'multer';
+import path from 'path';
+import { getExpressApiEventEventProcessor } from '../actionProcessor';
+import { getAllServiceConfigs } from '../allServiceConfig';
+import { processEvent } from '../logic';
+const getServiceBaseDomain = (qpqConfig, devServerConfig) => qpqWebServerUtils.getDomainRoot(`${devServerConfig.serverDomain}:${devServerConfig.serverPort}`, qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
+const getApiDomainsFromConfig = (qpqConfig, devServerConfig) => {
+    const baseDomain = getServiceBaseDomain(qpqConfig, devServerConfig);
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    // Get apis
+    const apiConfigs = qpqWebServerUtils.getApiConfigs(qpqConfig);
+    const apiDomains = apiConfigs.map((apiConfig) => ({
+        apiName: apiConfig.apiName,
+        service: serviceName,
+        qpqConfig,
+        domain: `${apiConfig.apiSubdomain}.${baseDomain}`,
+        devDomain: baseDomain,
+        devPath: `/${apiConfig.apiSubdomain}/${serviceName}`,
+    }));
+    return apiDomains;
+};
+const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async (runtime) => devServerConfig.dynamicModuleLoader(serviceName, runtime);
+};
+export const apiImplementation = async (devServerConfig) => {
+    const allServiceConfig = getAllServiceConfigs(devServerConfig);
+    const app = express();
+    app.use(multer().any());
+    app.use(bodyParser.json({ limit: '50mb' }));
+    const apiConfigs = allServiceConfig.map((qpqConfig) => getApiDomainsFromConfig(qpqConfig, devServerConfig)).flat();
+    console.log(apiConfigs.map((ac) => ac.devPath));
+    const adminFrontend = path.join(__dirname, '../../..', 'node_modules', 'quidproquo-web-admin', 'lib');
+    // Admin page
+    app.use('/admin', express.static(adminFrontend));
+    app.get('/admin/service/log/list', (req, res) => {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        const serviceList = allServiceConfig.map((qpqConfig) => qpqCoreUtils.getApplicationModuleName(qpqConfig)).map((name) => `api/${name}`);
+        res.json(serviceList);
+    });
+    app.use(express.json());
+    app.options('/admin/service/log/execute', async (req, res) => {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        res.json({ done: true });
+    });
+    app.get('/mf-manifest-location.json', async (req, res) => {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        res.json({ location: 'http://localhost:3005/mf-manifest.json' });
+    });
+    app.post('/admin/service/log/execute', async (req, res) => {
+        // Manually set CORS headers
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Credentials', 'false');
+        // TODO: Get list of services from config dynamically
+        const serviceLog = req.body;
+        let runtimeModule = askProcessEvent;
+        if (serviceLog.runtimeType === QpqRuntimeType.EXECUTE_STORY) {
+            const [srcEntry, module] = serviceLog.tags[0].split('::');
+            const loadedModule = await devServerConfig.dynamicModuleLoader(serviceLog.moduleName, srcEntry);
+            runtimeModule = loadedModule[module];
+        }
+        const result = await qpqExecuteLog(serviceLog, runtimeModule);
+        res.json(result);
+    });
+    // Proxy for all services
+    app.all('*', async (req, res) => {
+        const apiConfig = apiConfigs.find((c) => req.url.startsWith(`${c.devPath}/`));
+        if (apiConfig) {
+            console.log(`[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
+            const event = {
+                protocol: req.protocol,
+                host: req.get('host') || devServerConfig.serverDomain,
+                path: req.url.substring(apiConfig.devPath.length).split('?')[0],
+                ip: req.socket.remoteAddress || '127.0.0.1',
+                query: req.query,
+                correlation: '',
+                headers: req.headers,
+                method: req.method,
+                isBase64Encoded: false,
+                body: typeof req.body === 'object' ? JSON.stringify(req.body) : req.body,
+            };
+            if (req.files) {
+                event.files = req.files.map((file) => ({
+                    base64Data: file.buffer.toString('base64'),
+                    filename: file.originalname,
+                    mimetype: file.mimetype,
+                }));
+            }
+            const response = await processEvent(event, apiConfig.qpqConfig, getDynamicModuleLoader(apiConfig.qpqConfig, devServerConfig), getExpressApiEventEventProcessor, QpqRuntimeType.API);
+            if (response.result) {
+                for (const [header, value] of Object.entries(response.result.headers)) {
+                    res.set(header, value);
+                }
+                if (response.result.isBase64Encoded) {
+                    res.status(response.result.statusCode).send(Buffer.from(response.result.body, 'base64'));
+                }
+                else {
+                    res.status(response.result.statusCode).send(response.result.body);
+                }
+            }
+        }
+        else {
+            console.log(`NotFound::[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
+            res.status(500).send({ message: 'resource does not exist' });
+        }
+    });
+    app.listen(devServerConfig.serverPort, '0.0.0.0', () => {
+        const baseDomain = getServiceBaseDomain(allServiceConfig[0], devServerConfig);
+        console.log(`⚡️⚡️⚡️[Qpq - Dev Server]⚡️⚡️⚡️: Server is running at [http://${baseDomain}]`);
+    });
+};

package/lib/esm/implementations/eventBusImplementation.d.ts

@@ -0,0 +1,2 @@
+import { DevServerConfig } from '../types';
+export declare const eventBusImplementation: (devServerConfig: DevServerConfig) => Promise<void>;

package/lib/esm/implementations/eventBusImplementation.js

@@ -0,0 +1,40 @@
+import { EventBusActionType, qpqCoreUtils, QueueActionType } from 'quidproquo-core';
+import { v4 as uuidV4 } from 'uuid';
+import { eventBus } from '../logic';
+const processQueueEventBusSubscriptions = async (qpqConfig, ebMessage) => {
+    const allEventBuses = qpqCoreUtils.getAllEventBusConfigs(qpqConfig).filter((ebc) => {
+        return ((!ebc.owner?.application || ebc.owner?.application === ebMessage.targetApplication) &&
+            (!ebc.owner?.environment || ebc.owner?.environment === ebMessage.targetEnvironment) &&
+            (!ebc.owner?.module || ebc.owner?.module === ebMessage.targetModule) &&
+            ((!ebc.owner?.feature && !ebMessage.targetFeature) || ebc.owner?.feature === ebMessage.targetFeature));
+    });
+    // All the queues that we should publish to
+    const queues = qpqCoreUtils.getQueues(qpqConfig).filter((q) => {
+        return !!q.eventBusSubscriptions.find((ebsub) => {
+            return allEventBuses.some((eb) => ebsub === eb.owner?.resourceNameOverride || (!eb.owner?.resourceNameOverride && ebsub === eb.name));
+        });
+    });
+    for (const queue of queues) {
+        const queueMessage = {
+            payload: ebMessage.payload,
+            type: ebMessage.type,
+            storySession: ebMessage.storySession,
+            queueName: queue.name,
+            targetApplication: queue.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig),
+            targetEnvironment: queue.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig),
+            targetFeature: queue.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig),
+            targetModule: queue.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig),
+            messageId: uuidV4(),
+        };
+        eventBus.publish(QueueActionType.SendMessages, queueMessage);
+    }
+};
+export const eventBusImplementation = async (devServerConfig) => {
+    eventBus.on(EventBusActionType.SendMessages, async (payload, correlation) => {
+        for (const qpqConfig of devServerConfig.qpqConfigs) {
+            await processQueueEventBusSubscriptions(qpqConfig, payload);
+        }
+    });
+    // Never ends
+    await new Promise(() => { });
+};

package/lib/esm/implementations/index.d.ts

@@ -1 +1,4 @@
-export * from './route';
+export * from './apiImplementation';
+export * from './eventBusImplementation';
+export * from './queueImplementation';
+export * from './serviceFunctionImplementation';

package/lib/esm/implementations/index.js

@@ -1 +1,4 @@
-export * from './route';
+export * from './apiImplementation';
+export * from './eventBusImplementation';
+export * from './queueImplementation';
+export * from './serviceFunctionImplementation';

package/lib/esm/implementations/queueImplementation.d.ts

@@ -0,0 +1,2 @@
+import { DevServerConfig } from '../types';
+export declare const queueImplementation: (devServerConfig: DevServerConfig) => Promise<void>;

package/lib/esm/implementations/queueImplementation.js

@@ -0,0 +1,34 @@
+import { qpqCoreUtils, QpqRuntimeType, QueueActionType } from 'quidproquo-core';
+import { getQueueEventProcessor } from '../actionProcessor/core/event/queue';
+import { eventBus, processEvent } from '../logic';
+const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async (runtime) => devServerConfig.dynamicModuleLoader(serviceName, runtime);
+};
+const processQueueMessages = async (qpqConfig, payload, devServerConfig) => {
+    if (payload.targetEnvironment !== qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig)) {
+        return;
+    }
+    if (payload.targetApplication !== qpqCoreUtils.getApplicationName(qpqConfig)) {
+        return;
+    }
+    if (payload.targetModule !== qpqCoreUtils.getApplicationModuleName(qpqConfig)) {
+        return;
+    }
+    const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    if ((!!payload.targetFeature || !!feature) && payload.targetFeature !== qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig)) {
+        return;
+    }
+    console.log('Ready to process: ', JSON.stringify(payload, null, 2));
+    await processEvent(payload, qpqConfig, getDynamicModuleLoader(qpqConfig, devServerConfig), getQueueEventProcessor, QpqRuntimeType.QUEUE_EVENT);
+};
+export const queueImplementation = async (devServerConfig) => {
+    eventBus.on(QueueActionType.SendMessages, async (payload, correlation) => {
+        console.log('Got QUEUE send message event');
+        for (const qpqConfig of devServerConfig.qpqConfigs) {
+            await processQueueMessages(qpqConfig, payload, devServerConfig);
+        }
+    });
+    // Never ends
+    await new Promise(() => { });
+};

package/lib/esm/implementations/serviceFunctionImplementation.d.ts

@@ -0,0 +1,2 @@
+import { DevServerConfig } from '../types';
+export declare const serviceFunctionImplementation: (devServerConfig: DevServerConfig) => Promise<void>;

package/lib/esm/implementations/serviceFunctionImplementation.js

@@ -0,0 +1,21 @@
+import { qpqCoreUtils, QpqRuntimeType } from 'quidproquo-core';
+import { ServiceFunctionActionType } from 'quidproquo-webserver';
+import { getNodeServiceFunctionEventProcessor } from '../actionProcessor';
+import { eventBus, processEvent } from '../logic';
+const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async (runtime) => devServerConfig.dynamicModuleLoader(serviceName, runtime);
+};
+export const serviceFunctionImplementation = async (devServerConfig) => {
+    eventBus.on(ServiceFunctionActionType.Execute, async (payload, correlation) => {
+        // We need to find the qpqConfig for this service.
+        const qpqConfig = devServerConfig.qpqConfigs.find((qpqConfig) => qpqCoreUtils.getApplicationModuleName(qpqConfig) === payload.serviceName);
+        const eventPromise = await processEvent(payload, qpqConfig, getDynamicModuleLoader(qpqConfig, devServerConfig), getNodeServiceFunctionEventProcessor, QpqRuntimeType.SERVICE_FUNCTION_EXE);
+        if (correlation) {
+            // Emit the response back on the unique responseEvent channel
+            eventBus.emit(correlation, eventPromise);
+        }
+    });
+    // Never ends
+    await new Promise(() => { });
+};

package/lib/esm/logic/eventBus.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare class EventBus extends EventEmitter {
+    private static instance;
+    private constructor();
+    static getInstance(): EventBus;
+    publishAndWaitForResponse(eventType: string, payload: any): Promise<any>;
+    publish(eventType: string, payload: any): Promise<void>;
+}
+export declare const eventBus: EventBus;
+export {};

package/lib/esm/logic/eventBus.js

@@ -0,0 +1,31 @@
+// EventBus.ts
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+class EventBus extends EventEmitter {
+    static instance;
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!EventBus.instance) {
+            EventBus.instance = new EventBus();
+        }
+        return EventBus.instance;
+    }
+    async publishAndWaitForResponse(eventType, payload) {
+        return new Promise((resolve) => {
+            const responseCorrelation = uuidv4();
+            // Listen for the response once
+            this.once(responseCorrelation, (response) => {
+                resolve(response);
+            });
+            // Emit the event along with the response event name
+            this.emit(eventType, payload, responseCorrelation);
+        });
+    }
+    async publish(eventType, payload) {
+        this.emit(eventType, payload);
+    }
+}
+// Exporting a singleton instance of EventBus
+export const eventBus = EventBus.getInstance();

package/lib/esm/logic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './eventBus';
+export * from './processEvent';

package/lib/esm/logic/index.js

@@ -0,0 +1,2 @@
+export * from './eventBus';
+export * from './processEvent';

package/lib/esm/logic/processEvent.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver, DynamicModuleLoader, QPQConfig, QpqRuntimeType, StoryResult } from 'quidproquo-core';
+export declare const processEvent: <E, ER>(expressEvent: E, qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader, getActionProcessors: ActionProcessorListResolver, qpqRuntimeType: QpqRuntimeType) => Promise<StoryResult<[E], ER>>;

package/lib/esm/logic/processEvent.js

@@ -0,0 +1,20 @@
+import { getLogger } from 'quidproquo-actionprocessor-awslambda';
+import { askProcessEvent, createRuntime, qpqCoreUtils, } from 'quidproquo-core';
+import { randomUUID } from 'crypto';
+import { getDevServerActionProcessors } from '../actionProcessor';
+// TODO: Make this a util or something based on server time or something..
+const getDateNow = () => new Date().toISOString();
+export const processEvent = async (expressEvent, qpqConfig, dynamicModuleLoader, getActionProcessors, qpqRuntimeType) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const logger = getLogger(qpqConfig);
+    const resolveStory = createRuntime(qpqConfig, {
+        depth: 0,
+        context: {},
+    }, async () => ({
+        ...(await getDevServerActionProcessors(qpqConfig, dynamicModuleLoader)),
+        ...(await getActionProcessors(qpqConfig, dynamicModuleLoader)),
+    }), getDateNow, logger, `${serviceName}::${randomUUID()}`, qpqRuntimeType, dynamicModuleLoader, []);
+    const result = await resolveStory(askProcessEvent, [expressEvent]);
+    await logger.waitToFinishWriting();
+    return result;
+};

package/lib/esm/main.d.ts

@@ -1,2 +1,3 @@
 import { DevServerConfig } from './types';
+export * from './implementations';
 export declare const startDevServer: (devServerConfig: DevServerConfig) => Promise<void>;

package/lib/esm/main.js

@@ -1,125 +1,11 @@
-import { askProcessEvent, qpqCoreUtils, qpqExecuteLog, QpqRuntimeType } from 'quidproquo-core';
-import { qpqWebServerUtils } from 'quidproquo-webserver';
-import bodyParser from 'body-parser';
-import express from 'express';
-import multer from 'multer';
-import path from 'path';
-import { getAllServiceConfigs } from './allServiceConfig';
-import { route } from './implementations';
-const getServiceBaseDomain = (qpqConfig, devServerConfig) => qpqWebServerUtils.getDomainRoot(`${devServerConfig.serverDomain}:${devServerConfig.serverPort}`, qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
-const getApiDomainsFromConfig = (qpqConfig, devServerConfig) => {
-    const baseDomain = getServiceBaseDomain(qpqConfig, devServerConfig);
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
-    // Get apis
-    const apiConfigs = qpqWebServerUtils.getApiConfigs(qpqConfig);
-    const apiDomains = apiConfigs.map((apiConfig) => ({
-        apiName: apiConfig.apiName,
-        service: serviceName,
-        qpqConfig,
-        domain: `${apiConfig.apiSubdomain}.${baseDomain}`,
-        devDomain: baseDomain,
-        devPath: `/${apiConfig.apiSubdomain}/${serviceName}`,
-    }));
-    return apiDomains;
-};
-const getDynamicModuleLoader = (qpqConfig, devServerConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
-    return async (runtime) => devServerConfig.dynamicModuleLoader(serviceName, runtime);
-};
+import { apiImplementation, eventBusImplementation, queueImplementation, serviceFunctionImplementation } from './implementations';
+export * from './implementations';
 export const startDevServer = async (devServerConfig) => {
-    const allServiceConfig = await getAllServiceConfigs(devServerConfig);
-    const app = express();
-    app.use(multer().any());
-    app.use(bodyParser.json({ limit: '50mb' }));
-    const apiConfigs = allServiceConfig.map((qpqConfig) => getApiDomainsFromConfig(qpqConfig, devServerConfig)).flat();
-    const adminFrontend = path.join(__dirname, '../../..', 'node_modules', 'quidproquo-web-admin', 'lib');
-    // Admin page
-    app.use('/admin', express.static(adminFrontend));
-    app.get('/admin/service/log/list', (req, res) => {
-        // Manually set CORS headers
-        res.header('Access-Control-Allow-Headers', '*');
-        res.header('Access-Control-Allow-Methods', '*');
-        res.header('Access-Control-Allow-Origin', '*');
-        res.header('Access-Control-Allow-Credentials', 'false');
-        const serviceList = allServiceConfig.map((qpqConfig) => qpqCoreUtils.getApplicationModuleName(qpqConfig)).map((name) => `api/${name}`);
-        res.json(serviceList);
-    });
-    app.use(express.json());
-    app.options('/admin/service/log/execute', async (req, res) => {
-        // Manually set CORS headers
-        res.header('Access-Control-Allow-Headers', '*');
-        res.header('Access-Control-Allow-Methods', '*');
-        res.header('Access-Control-Allow-Origin', '*');
-        res.header('Access-Control-Allow-Credentials', 'false');
-        res.json({ done: true });
-    });
-    app.get('/mf-manifest-location.json', async (req, res) => {
-        // Manually set CORS headers
-        res.header('Access-Control-Allow-Headers', '*');
-        res.header('Access-Control-Allow-Methods', '*');
-        res.header('Access-Control-Allow-Origin', '*');
-        res.header('Access-Control-Allow-Credentials', 'false');
-        res.json({ location: 'http://localhost:3005/mf-manifest.json' });
-    });
-    app.post('/admin/service/log/execute', async (req, res) => {
-        // Manually set CORS headers
-        res.header('Access-Control-Allow-Headers', '*');
-        res.header('Access-Control-Allow-Methods', '*');
-        res.header('Access-Control-Allow-Origin', '*');
-        res.header('Access-Control-Allow-Credentials', 'false');
-        // TODO: Get list of services from config dynamically
-        const serviceLog = req.body;
-        let runtimeModule = askProcessEvent;
-        if (serviceLog.runtimeType === QpqRuntimeType.EXECUTE_STORY) {
-            const [srcEntry, module] = serviceLog.tags[0].split('::');
-            const loadedModule = await devServerConfig.dynamicModuleLoader(serviceLog.moduleName, srcEntry);
-            runtimeModule = loadedModule[module];
-        }
-        const result = await qpqExecuteLog(serviceLog, runtimeModule);
-        res.json(result);
-    });
-    // Proxy for all services
-    app.all('*', async (req, res) => {
-        const apiConfig = apiConfigs.find((c) => req.url.startsWith(`${c.devPath}/`));
-        if (apiConfig) {
-            console.log(`[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
-            const event = {
-                protocol: req.protocol,
-                host: req.get('host') || devServerConfig.serverDomain,
-                path: req.url.substring(apiConfig.devPath.length).split('?')[0],
-                ip: req.socket.remoteAddress || '127.0.0.1',
-                query: req.query,
-                correlation: '',
-                headers: req.headers,
-                method: req.method,
-                isBase64Encoded: false,
-                body: typeof req.body === 'object' ? JSON.stringify(req.body) : req.body,
-            };
-            if (req.files) {
-                event.files = req.files.map((file) => ({
-                    base64Data: file.buffer.toString('base64'),
-                    filename: file.originalname,
-                    mimetype: file.mimetype,
-                }));
-            }
-            const response = await route(event, apiConfig.qpqConfig, getDynamicModuleLoader(apiConfig.qpqConfig, devServerConfig));
-            for (const [header, value] of Object.entries(response.headers)) {
-                res.set(header, value);
-            }
-            if (response.isBase64Encoded) {
-                res.status(response.statusCode).send(Buffer.from(response.body, 'base64'));
-            }
-            else {
-                res.status(response.statusCode).send(response.body);
-            }
-        }
-        else {
-            console.log(`NotFound::[${req.method}::${req.socket.remoteAddress}]: ${req.protocol}://${req.get('host')}${req.url}`);
-            res.status(500).send({ message: 'resource does not exist' });
-        }
-    });
-    app.listen(devServerConfig.serverPort, '0.0.0.0', () => {
-        const baseDomain = getServiceBaseDomain(allServiceConfig[0], devServerConfig);
-        console.log(`⚡️⚡️⚡️[Qpq - Dev Server]⚡️⚡️⚡️: Server is running at [http://${baseDomain}]`);
-    });
+    console.log('Starting QPQ Dev Server!!!');
+    await Promise.all([
+        apiImplementation(devServerConfig),
+        serviceFunctionImplementation(devServerConfig),
+        eventBusImplementation(devServerConfig),
+        queueImplementation(devServerConfig),
+    ]);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quidproquo-dev-server",
-  "version": "0.0.237",
+  "version": "0.0.239",
   "description": "",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/esm/index.js",
@@ -33,14 +33,14 @@
   "homepage": "https://github.com/joe-coady/quidproquo#readme",
   "dependencies": {
     "multer": "^1.4.5-lts.1",
-    "quidproquo-core": "0.0.237",
-    "quidproquo-webserver": "0.0.237",
-    "quidproquo-actionprocessor-awslambda": "0.0.237",
-    "quidproquo-actionprocessor-node": "0.0.237"
+    "quidproquo-core": "0.0.239",
+    "quidproquo-webserver": "0.0.239",
+    "quidproquo-actionprocessor-awslambda": "0.0.239",
+    "quidproquo-actionprocessor-node": "0.0.239"
   },
   "devDependencies": {
     "@types/multer": "^1.4.12",
-    "quidproquo-tsconfig": "0.0.237",
+    "quidproquo-tsconfig": "0.0.239",
     "typescript": "^4.9.3"
   }
 }

package/lib/commonjs/getActionProcessor/core/event/index.d.ts

@@ -1 +0,0 @@
-export * from './express';

package/lib/commonjs/getActionProcessor/core/index.d.ts

@@ -1 +0,0 @@
-export * from './event';

package/lib/commonjs/getActionProcessor/index.d.ts

@@ -1 +0,0 @@
-export * from './core';

package/lib/commonjs/implementations/route.d.ts

@@ -1,3 +0,0 @@
-import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
-import { ExpressEvent, ExpressEventResponse } from '../types';
-export declare const route: (expressEvent: ExpressEvent, qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader) => Promise<ExpressEventResponse>;