Merge pull request #16 from Virtual-Finland-Development/feat/url-redirector-for-testbed-gw

lsipii · web-flow · commit 8f2f03935176 · 2023-04-19T12:39:38.000+03:00
feat: add uri redirector for special request paths
diff --git a/infra/package-lock.json b/infra/package-lock.json
diff --git a/infra/resources/CloudFront.ts b/infra/resources/CloudFront.ts
@@ -30,7 +30,7 @@ export function createCloudFrontDistribution(
         ],
         customErrorResponses: [],
         defaultCacheBehavior: {
-            allowedMethods: ['GET', 'HEAD', 'OPTIONS'],
+            allowedMethods: ['HEAD', 'DELETE', 'POST', 'GET', 'OPTIONS', 'PUT', 'PATCH'],
             cachedMethods: ['GET', 'HEAD'],
             targetOriginId: bucket.arn,
             viewerProtocolPolicy: 'redirect-to-https',
diff --git a/infra/resources/S3Bucket.ts b/infra/resources/S3Bucket.ts
@@ -18,7 +18,7 @@ export default function createS3Bucket(setup: ISetup) {
         corsRules: [
             {
                 allowedHeaders: ['*'],
-                allowedMethods: ['GET'],
+                allowedMethods: ['GET', 'POST'],
                 allowedOrigins: ['*'],
             },
         ],
diff --git a/src/app.test.ts b/src/app.test.ts
@@ -17,8 +17,15 @@ test('Basic router test', async () => {
         ],
     } as CloudFrontRequestEvent;
     */
+
+    // Mock event
     const event = {
         rawPath: '/resources/bazz',
+        requestContext: {
+            http: {
+                method: 'GET',
+            },
+        },
     } as unknown as APIGatewayProxyEventV2;
 
     const result = (await offlineHandler(event)) as unknown as APIGatewayProxyStructuredResultV2;
diff --git a/src/app.ts b/src/app.ts
@@ -7,19 +7,19 @@ import {
 } from 'aws-lambda';
 import mime from 'mime';
 import { InternalResources } from './resources/index';
+import { resolveError, resolveUri } from './utils/api';
 import { getResource, listResources } from './utils/data/repositories/ResourceRepository';
-import { cutTooLongString, generateSimpleHash } from './utils/helpers';
+import { cutTooLongString, decodeBase64, generateSimpleHash, parseRequestInputParams } from './utils/helpers';
 import { storeToS3 } from './utils/lib/S3Bucket';
 import { Environment, getInternalResourceInfo } from './utils/runtime';
 
 async function engageResourcesRouter(
     resourceURI: string,
-    queryParams: string
+    params: Record<string, string>
 ): Promise<{
     response: CloudFrontResultResponse | undefined;
     cacheable?: { filepath: string; data: string; mime: string };
 }> {
-    const urlParams = Object.fromEntries(new URLSearchParams(queryParams || ''));
     const resourceName = resourceURI.replace('/resources', '').replace('/', ''); // First occurence of "/" is removed
     if (!resourceName) {
         // On a requets path /resources, return a list of resources
@@ -35,15 +35,15 @@ async function engageResourcesRouter(
     const resource = getResource(resourceName);
     if (resource) {
         console.log('Resource: ', resource.name);
-        const resourceResponse = await resource.retrieve(urlParams);
+        const resourceResponse = await resource.retrieve(params);
 
         // If resource size is larger than 1MB, store it in S3 and redirect to it instead
         // This is a workaround to avoid CloudFront cache limit
         // @see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-functions-restrictions.html#lambda-at-edge-function-restrictions
         console.log('Size: ', resourceResponse.size, 'bytes');
         if (resourceResponse.size > 1024 * 1024) {
             const extension = mime.getExtension(resourceResponse.mime);
-            const cachedName = `/cached/${resource.name}-${generateSimpleHash(urlParams)}.${extension}`;
+            const cachedName = `/cached/${resource.name}-${generateSimpleHash(params)}.${extension}`;
 
             return {
                 response: undefined,
@@ -96,15 +96,26 @@ async function engageResourcesRouter(
 export async function handler(event: CloudFrontRequestEvent): Promise<CloudFrontRequestResult> {
     try {
         const request = event.Records[0].cf.request;
-        let uri = request.uri;
-        const queryParams = request.querystring;
+        let uri = resolveUri(request.uri);
+        const params = Object.fromEntries(new URLSearchParams(request.querystring || ''));
+        if (request.method === 'POST' && typeof request.body?.data === 'string') {
+            try {
+                const body = JSON.parse(decodeBase64(request.body.data));
+                if (typeof body === 'object') {
+                    Object.assign(params, parseRequestInputParams(body));
+                }
+            } catch (error) {
+                //
+            }
+        }
+
         console.log('Request: ', {
             uri,
-            queryParams,
+            params,
         });
 
         if (uri.startsWith('/resources')) {
-            const routerResponse = await engageResourcesRouter(uri, queryParams);
+            const routerResponse = await engageResourcesRouter(uri, params);
             if (routerResponse.response) {
                 console.log('Response: ', {
                     ...routerResponse.response,
@@ -130,14 +141,30 @@ export async function handler(event: CloudFrontRequestEvent): Promise<CloudFront
             }
         }
 
+        if (request.method === 'POST') {
+            // If the request is POST, we need to use a redirect for the cache to work
+            return {
+                status: '302',
+                statusDescription: 'Found',
+                headers: {
+                    location: [
+                        {
+                            key: 'Location',
+                            value: uri,
+                        },
+                    ],
+                },
+            };
+        }
+
         request.uri = uri; // Pass through to origin
         return request;
     } catch (error: any) {
-        console.log(error?.message, error?.stack);
+        const errorPackage = resolveError(error);
         return {
-            status: '500',
-            statusDescription: 'Internal Server Error',
-            body: JSON.stringify({ message: error?.message }),
+            status: errorPackage.statusCode.toString(),
+            statusDescription: errorPackage.description,
+            body: errorPackage.body,
         };
     }
 }
@@ -153,15 +180,26 @@ export async function offlineHandler(event: APIGatewayProxyEventV2): Promise<API
         Environment.isLocal = true;
 
         const handle = async (event: APIGatewayProxyEventV2) => {
-            let uri = event.rawPath;
-            const queryParams = event.rawQueryString;
+            let uri = resolveUri(event.rawPath);
+            const params = Object.fromEntries(new URLSearchParams(event.rawQueryString || ''));
+            if (event.requestContext.http.method === 'POST') {
+                try {
+                    const body = JSON.parse(event.body || '{}');
+                    if (typeof body === 'object') {
+                        Object.assign(params, parseRequestInputParams(body));
+                    }
+                } catch (error) {
+                    //
+                }
+            }
+
             console.log('Request: ', {
                 uri,
-                queryParams,
+                params,
             });
 
             if (uri.startsWith('/resources')) {
-                const routerResponse: any = await engageResourcesRouter(uri, queryParams);
+                const routerResponse: any = await engageResourcesRouter(uri, params);
                 if (routerResponse.response) {
                     return {
                         statusCode: parseInt(routerResponse.response.status),
@@ -209,10 +247,6 @@ export async function offlineHandler(event: APIGatewayProxyEventV2): Promise<API
 
         return await Promise.race([handle(event), internalTimeoutEnforcer() as any]); // Return the first to resolve
     } catch (error: any) {
-        console.log(error?.message, error?.stack);
-        return {
-            statusCode: 500,
-            body: JSON.stringify({ message: error?.message }),
-        };
+        return resolveError(error);
     }
 }
diff --git a/src/resources/internal/BusinessFinlandEscoOccupations.ts b/src/resources/internal/BusinessFinlandEscoOccupations.ts
@@ -2,6 +2,8 @@ import InternalResource from '../../utils/data/models/InternalResource';
 import { getOutput } from '../../utils/data/parsers';
 import { getPaginationParams } from '../../utils/filters';
 
+import BusinessFinlandDataSet from './business-finland-esco-v1_1_1-occupations.json';
+
 interface Occupation {
     escoCode: string;
     escoJobTitle: string;
@@ -35,4 +37,10 @@ export default new InternalResource({
             return getOutput()<OccupationsResponse>(data);
         },
     },
+    dataGetter() {
+        return Promise.resolve({
+            data: JSON.stringify(BusinessFinlandDataSet),
+            mime: 'application/json',
+        });
+    },
 });
diff --git a/src/utils/api.ts b/src/utils/api.ts
@@ -0,0 +1,21 @@
+const UriRedirects: Record<string, string> = {
+    '/productizer/draft/Employment/EscoOccupations': '/resources/BusinessFinlandEscoOccupations',
+};
+
+export function resolveUri(uri: string): string {
+    return UriRedirects[uri] || uri;
+}
+
+export function resolveError(error: Error): { statusCode: number; body: string; description: string } {
+    const errorPackage = resolveErrorPackage(error);
+    console.error('Error: ', errorPackage);
+    return errorPackage;
+}
+
+function resolveErrorPackage(error: Error): { statusCode: number; body: string; description: string } {
+    return {
+        statusCode: 500,
+        description: 'Internal Server Error',
+        body: error.message || 'Internal Server Error',
+    };
+}
diff --git a/src/utils/data/models/InternalResource.ts b/src/utils/data/models/InternalResource.ts
@@ -3,28 +3,44 @@ import { retrieveFromS3 } from '../../lib/S3Bucket';
 import { Environment, getInternalResourceInfo } from '../../runtime';
 import BaseResource from './internal/BaseResource';
 
+const inMemoryCache: Record<
+    string,
+    {
+        data: string;
+        mime: string;
+    }
+> = {};
+
 export default class InternalResource extends BaseResource {
     public type = 'internal';
 
     protected async _retrieveDataPackage(): Promise<{
         data: string;
         mime: string;
     }> {
+        if (typeof inMemoryCache[this.uri] !== 'undefined') {
+            console.log('Using in-memory cache for resource');
+            return inMemoryCache[this.uri];
+        }
+
         const fileName = this.uri;
 
         if (Environment.isLocal) {
             const resource = await InternalResources.getResourcePassThrough(fileName);
             if (resource) {
-                return {
+                inMemoryCache[this.uri] = {
                     data: resource.body,
                     mime: resource.mime || 'application/json',
                 };
+
+                return inMemoryCache[this.uri];
             }
             throw new Error(`Resource ${fileName} not found`);
         }
 
         const bucketName = getInternalResourceInfo().name;
         const bucketKey = `resources/${fileName}`;
-        return retrieveFromS3(bucketName, bucketKey);
+        inMemoryCache[this.uri] = await retrieveFromS3(bucketName, bucketKey);
+        return inMemoryCache[this.uri];
     }
 }
diff --git a/src/utils/data/models/internal/BaseResource.ts b/src/utils/data/models/internal/BaseResource.ts
@@ -20,9 +20,10 @@ export default class BaseResource implements IResource {
         input?: (data: string) => unknown;
         transform?: (data: unknown, params: Record<string, string>) => Promise<unknown>;
         output?: (data: unknown) => string;
-    } = {};
+    };
 
     protected _dataGetter: ((params: Record<string, string>) => Promise<{ data: string; mime: string }>) | undefined;
+    protected _settings: Record<string, string | number | boolean>;
 
     constructor({
         name,
@@ -31,6 +32,7 @@ export default class BaseResource implements IResource {
         type,
         dataGetter,
         parsers,
+        settings,
     }: {
         name: string;
         type?: 'external' | 'library' | 'internal';
@@ -42,34 +44,31 @@ export default class BaseResource implements IResource {
             transform?: (data: unknown, params: Record<string, string>) => Promise<unknown>; // Data intake -> transformed data
             output?: (data: unknown) => string; // Transformed data intake -> raw output data
         };
+        settings?: Record<string, string | number | boolean>;
     }) {
         this.name = name;
         this.uri = uri || '';
         this.type = type || this.type;
         this._mime = mime;
         this._dataGetter = dataGetter;
         this._parsers = parsers || {};
+        this._settings = settings || {};
     }
 
     public async retrieve(params: Record<string, string>): Promise<{
         data: string;
         mime: string;
         size: number;
     }> {
-        try {
-            this.validateSelf();
-            const dataPackage = await this._retrieveDataPackage(params);
-            const mime = this._mime || dataPackage.mime;
-            const finalData = await this._parseRawData(dataPackage.data, mime, params);
-            return {
-                data: finalData,
-                mime: mime,
-                size: Buffer.byteLength(finalData, 'utf8'),
-            };
-        } catch (error) {
-            console.log(error);
-            throw error;
-        }
+        this.validateSelf();
+        const dataPackage = await this._retrieveDataPackage(params);
+        const mime = this._mime || dataPackage.mime;
+        const finalData = await this._parseRawData(dataPackage.data, mime, params);
+        return {
+            data: finalData,
+            mime: mime,
+            size: Buffer.byteLength(finalData, 'utf8'),
+        };
     }
 
     private validateSelf(): void {
diff --git a/src/utils/filters.ts b/src/utils/filters.ts
diff --git a/src/utils/helpers.ts b/src/utils/helpers.ts

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ export default function createS3Bucket(setup: ISetup) {`
`18`	`18`	`corsRules: [`
`19`	`19`	`{`
`20`	`20`	`allowedHeaders: ['*'],`
`21`		`- allowedMethods: ['GET'],`
	`21`	`+ allowedMethods: ['GET', 'POST'],`
`22`	`22`	`allowedOrigins: ['*'],`
`23`	`23`	`},`
`24`	`24`	`],`