fix: modernize docker publishing

ts/rendertron.classes.rendertron.ts

@@ -1,21 +1,23 @@
 import * as plugins from './rendertron.plugins.js';
 import * as paths from './rendertron.paths.js';
 import { logger } from './rendertron.logging.js';
+import { db } from './rendertron.db.js';
 import { PrerenderResult } from './rendertron.classes.prerenderresult.js';
 import { PrerenderManager } from './rendertron.classes.prerendermanager.js';
 import { TaskManager } from './rendertron.taskmanager.js';
 
 export class Rendertron {
-  public projectinfo: plugins.projectinfo.ProjectInfo;
-  public serviceServerInstance: plugins.typedserver.utilityservers.UtilityServiceServer;
-  public prerenderManager: PrerenderManager;
-  public taskManager: TaskManager;
+  public projectinfo!: plugins.projectinfo.ProjectInfo;
+  public serviceServerInstance!: plugins.typedserver.utilityservers.UtilityServiceServer;
+  public prerenderManager!: PrerenderManager;
+  public taskManager!: TaskManager;
 
   /**
    * starts the financeflow instance
    */
   public async start() {
-    this.projectinfo = new plugins.projectinfo.ProjectInfo(paths.packageDir);
+    this.projectinfo = await plugins.projectinfo.ProjectInfo.create(paths.packageDir);
+    await db.init();
     this.prerenderManager = new PrerenderManager();
     this.taskManager = new TaskManager(this);
     await this.prerenderManager.start();
@@ -27,55 +29,49 @@ export class Rendertron {
       addCustomRoutes: async (serverArg) => {
         serverArg.addRoute(
           '/render/*',
-          new plugins.typedserver.servertools.Handler('GET', async (req, res) => {
-            const requestedUrl = req.url.replace('/render/', '');
+          'GET',
+          async (ctxArg) => {
+            const requestedUrl = `${ctxArg.url.pathname.replace('/render/', '')}${ctxArg.url.search}`;
             logger.log('info', `Got SSR request for ${requestedUrl}`);
             if (requestedUrl.startsWith('https://url(')) {
               logger.log('warn', `relative url error for ${requestedUrl}`);
-              res.status(500);
-              res.write('error due to relative protocol');
-              res.end();
-              return;
+              return new Response('error due to relative protocol', { status: 500 });
             }
-            const originResponse = await plugins.smartrequest
-              .request(
-                requestedUrl,
-                {
-                  method: 'GET',
-                  keepAlive: false,
-                  // headers: req.headers,
-                },
-                true
-              )
+            const originResponse = await plugins.smartrequest.SmartRequest.create()
+              .url(requestedUrl)
+              .options({ keepAlive: false })
+              .get()
               .catch((error) => {
                 logger.log('warn', `the origin request errored for ${requestedUrl}`);
-                res.write(`rendertron encountered an error for ${requestedUrl}`);
-                res.end();
+                return null;
               });
             if (!originResponse) {
-              return;
+              return new Response(`rendertron encountered an error for ${requestedUrl}`, { status: 502 });
             }
-            for (const header of Object.keys(originResponse.headers)) {
-              res.setHeader(header, originResponse.headers[header]);
+            const responseHeaders = new Headers();
+            for (const [headerKey, headerValue] of Object.entries(originResponse.headers)) {
+              if (Array.isArray(headerValue)) {
+                for (const headerValueItem of headerValue) {
+                  responseHeaders.append(headerKey, headerValueItem);
+                }
+              } else if (headerValue !== undefined) {
+                responseHeaders.set(headerKey, headerValue.toString());
+              }
             }
             if (originResponse.headers['content-type']?.includes('text/html')) {
               logger.log('info', `Piping ${requestedUrl} through smartssr.`);
-              res.write(await this.prerenderManager.getPrerenderResultForUrl(requestedUrl));
-              res.end();
+              return new Response(await this.prerenderManager.getPrerenderResultForUrl(requestedUrl), {
+                status: originResponse.status,
+                headers: responseHeaders,
+              });
             } else {
               logger.log('info', `Serving ${requestedUrl} directly.`);
-              for (const headerKey of Object.keys(originResponse.headers)) {
-                console.log(`${headerKey}: ${originResponse.headers[headerKey]}`);
-                res.set(headerKey, originResponse.headers[headerKey]);
-              }
-              originResponse.on('data', (data) => {
-                res.write(data);
-              });
-              originResponse.on('end', () => {
-                res.end();
+              return new Response(await originResponse.arrayBuffer(), {
+                status: originResponse.status,
+                headers: responseHeaders,
               });
             }
-          })
+          }
         );
       },
     });
@@ -86,5 +82,8 @@ export class Rendertron {
     this.serviceServerInstance ? await this.serviceServerInstance.stop() : null;
     this.prerenderManager ? await this.prerenderManager.stop() : null;
     this.taskManager ? await this.taskManager.stop() : null;
+    if (db.status === 'connected') {
+      await db.close();
+    }
   }
 }