Migrate to Deno (#86)

Big bang migration to Deno 🤯
2022-10-10 14:50:21 +02:00
parent 78f83c70d8
commit 561aa6891f
287 changed files with 4577 additions and 25087 deletions
@@ -0,0 +1,78 @@
+import { Hook, Manifest } from "../types.ts";
+import { Cron } from "https://cdn.jsdelivr.net/gh/hexagon/croner@4/src/croner.js";
+import { safeRun } from "../util.ts";
+import { System } from "../system.ts";
+
+export type CronHookT = {
+  cron?: string | string[];
+};
+
+export class DenoCronHook implements Hook<CronHookT> {
+  apply(system: System<CronHookT>): void {
+    let tasks: Cron[] = [];
+    system.on({
+      plugLoaded: () => {
+        reloadCrons();
+      },
+      plugUnloaded() {
+        reloadCrons();
+      },
+    });
+
+    reloadCrons();
+
+    function reloadCrons() {
+      tasks.forEach((task) => task.stop());
+      tasks = [];
+      for (let plug of system.loadedPlugs.values()) {
+        if (!plug.manifest) {
+          continue;
+        }
+        for (
+          const [name, functionDef] of Object.entries(
+            plug.manifest.functions,
+          )
+        ) {
+          if (!functionDef.cron) {
+            continue;
+          }
+          const crons = Array.isArray(functionDef.cron)
+            ? functionDef.cron
+            : [functionDef.cron];
+          for (const cronDef of crons) {
+            tasks.push(
+              new Cron(cronDef, () => {
+                console.log("Now acting on cron", cronDef);
+                safeRun(async () => {
+                  try {
+                    await plug.invoke(name, [cronDef]);
+                  } catch (e: any) {
+                    console.error("Execution of cron function failed", e);
+                  }
+                });
+              }),
+            );
+          }
+        }
+      }
+    }
+  }
+
+  validateManifest(manifest: Manifest<CronHookT>): string[] {
+    let errors: string[] = [];
+    for (const [name, functionDef] of Object.entries(manifest.functions)) {
+      if (!functionDef.cron) {
+        continue;
+      }
+      const crons = Array.isArray(functionDef.cron)
+        ? functionDef.cron
+        : [functionDef.cron];
+      for (let cronDef of crons) {
+        // if (!cron.validate(cronDef)) {
+        //   errors.push(`Invalid cron expression ${cronDef}`);
+        // }
+      }
+    }
+    return errors;
+  }
+}
@@ -0,0 +1,48 @@
+import { createSandbox } from "../environments/deno_sandbox.ts";
+import { Manifest } from "../types.ts";
+import { EndpointHook, EndpointHookT } from "./endpoint.ts";
+import { System } from "../system.ts";
+
+import { Application } from "../../server/deps.ts";
+import { assertEquals } from "../../test_deps.ts";
+
+Deno.test("Run a plugos endpoint server", async () => {
+  let system = new System<EndpointHookT>("server");
+  let plug = await system.load(
+    {
+      name: "test",
+      functions: {
+        testhandler: {
+          http: {
+            path: "/",
+          },
+          code: `(() => {
+          return {
+            default: (req) => {
+              console.log("Req", req);
+              return {status: 200, body: [1, 2, 3], headers: {"Content-type": "application/json"}};
+            }
+          };
+        })()`,
+        },
+      },
+    } as Manifest<EndpointHookT>,
+    createSandbox,
+  );
+
+  const app = new Application();
+  const port = 3123;
+
+  system.addHook(new EndpointHook(app, "/_"));
+
+  const controller = new AbortController();
+  app.listen({ port: port, signal: controller.signal });
+
+  const res = await fetch(`http://localhost:${port}/_/test/?name=Pete`);
+  assertEquals(res.status, 200);
+  assertEquals(res.headers.get("Content-type"), "application/json");
+  assertEquals(await res.json(), [1, 2, 3]);
+  console.log("Aborting");
+  controller.abort();
+  await system.unloadAll();
+});
@@ -0,0 +1,136 @@
+import { Hook, Manifest } from "../types.ts";
+import { System } from "../system.ts";
+import { Application } from "../../server/deps.ts";
+
+export type EndpointRequest = {
+  method: string;
+  path: string;
+  query: { [key: string]: string };
+  headers: { [key: string]: string };
+  body: any;
+};
+
+export type EndpointResponse = {
+  status: number;
+  headers?: { [key: string]: string };
+  body: any;
+};
+
+export type EndpointHookT = {
+  http?: EndPointDef | EndPointDef[];
+};
+
+export type EndPointDef = {
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "ANY";
+  path: string;
+};
+
+export class EndpointHook implements Hook<EndpointHookT> {
+  private app: Application;
+  readonly prefix: string;
+
+  constructor(app: Application, prefix: string) {
+    this.app = app;
+    this.prefix = prefix;
+  }
+
+  apply(system: System<EndpointHookT>): void {
+    this.app.use(async (ctx, next) => {
+      const req = ctx.request;
+      const requestPath = ctx.request.url.pathname;
+      if (!requestPath.startsWith(this.prefix)) {
+        return next();
+      }
+      console.log("Endpoint request", requestPath);
+      // Iterate over all loaded plugins
+      for (const [plugName, plug] of system.loadedPlugs.entries()) {
+        const manifest = plug.manifest;
+        if (!manifest) {
+          continue;
+        }
+        const functions = manifest.functions;
+        console.log("Checking plug", plugName);
+        let prefix = `${this.prefix}/${plugName}`;
+        if (!requestPath.startsWith(prefix)) {
+          continue;
+        }
+        for (const [name, functionDef] of Object.entries(functions)) {
+          if (!functionDef.http) {
+            continue;
+          }
+          let endpoints = Array.isArray(functionDef.http)
+            ? functionDef.http
+            : [functionDef.http];
+          console.log(endpoints);
+          for (const { path, method } of endpoints) {
+            let prefixedPath = `${prefix}${path}`;
+            if (
+              prefixedPath === requestPath &&
+              ((method || "GET") === req.method || method === "ANY")
+            ) {
+              try {
+                const response: EndpointResponse = await plug.invoke(name, [
+                  {
+                    path: req.url.pathname,
+                    method: req.method,
+                    body: req.body(),
+                    query: Object.fromEntries(
+                      req.url.searchParams.entries(),
+                    ),
+                    headers: Object.fromEntries(req.headers.entries()),
+                  } as EndpointRequest,
+                ]);
+                if (response.headers) {
+                  for (
+                    const [key, value] of Object.entries(
+                      response.headers,
+                    )
+                  ) {
+                    ctx.response.headers.set(key, value);
+                  }
+                }
+                ctx.response.status = response.status;
+                ctx.response.body = response.body;
+                console.log("Sent result");
+                return;
+              } catch (e: any) {
+                console.error("Error executing function", e);
+                ctx.response.status = 500;
+                ctx.response.body = e.message;
+                return;
+              }
+            }
+          }
+        }
+      }
+      // console.log("Shouldn't get here");
+      next();
+    });
+  }
+
+  validateManifest(manifest: Manifest<EndpointHookT>): string[] {
+    let errors = [];
+    for (const [name, functionDef] of Object.entries(manifest.functions)) {
+      if (!functionDef.http) {
+        continue;
+      }
+      let endpoints = Array.isArray(functionDef.http)
+        ? functionDef.http
+        : [functionDef.http];
+      for (let { path, method } of endpoints) {
+        if (!path) {
+          errors.push("Path not defined for endpoint");
+        }
+        if (
+          method &&
+          ["GET", "POST", "PUT", "DELETE", "ANY"].indexOf(method) === -1
+        ) {
+          errors.push(
+            `Invalid method ${method} for end point with with ${path}`,
+          );
+        }
+      }
+    }
+    return errors;
+  }
+}
@@ -0,0 +1,104 @@
+import type { Hook, Manifest } from "../types.ts";
+import { System } from "../system.ts";
+import { safeRun } from "../util.ts";
+
+// System events:
+// - plug:load (plugName: string)
+
+export type EventHookT = {
+  events?: string[];
+};
+
+export class EventHook implements Hook<EventHookT> {
+  private system?: System<EventHookT>;
+  public localListeners: Map<string, ((data: any) => any)[]> = new Map();
+
+  addLocalListener(eventName: string, callback: (data: any) => any) {
+    if (!this.localListeners.has(eventName)) {
+      this.localListeners.set(eventName, []);
+    }
+    this.localListeners.get(eventName)!.push(callback);
+  }
+
+  // Pull all events listened to
+  listEvents(): string[] {
+    if (!this.system) {
+      throw new Error("Event hook is not initialized");
+    }
+    const eventNames = new Set<string>();
+    for (const plug of this.system.loadedPlugs.values()) {
+      for (const functionDef of Object.values(plug.manifest!.functions)) {
+        if (functionDef.events) {
+          for (const eventName of functionDef.events) {
+            eventNames.add(eventName);
+          }
+        }
+      }
+    }
+    for (const eventName of this.localListeners.keys()) {
+      eventNames.add(eventName);
+    }
+
+    return [...eventNames];
+  }
+
+  async dispatchEvent(eventName: string, data?: any): Promise<any[]> {
+    if (!this.system) {
+      throw new Error("Event hook is not initialized");
+    }
+    const responses: any[] = [];
+    for (const plug of this.system.loadedPlugs.values()) {
+      for (
+        const [name, functionDef] of Object.entries(
+          plug.manifest!.functions,
+        )
+      ) {
+        if (functionDef.events && functionDef.events.includes(eventName)) {
+          // Only dispatch functions that can run in this environment
+          if (plug.canInvoke(name)) {
+            const result = await plug.invoke(name, [data]);
+            if (result !== undefined) {
+              responses.push(result);
+            }
+          }
+        }
+      }
+    }
+    const localListeners = this.localListeners.get(eventName);
+    if (localListeners) {
+      for (const localListener of localListeners) {
+        const result = await Promise.resolve(localListener(data));
+        if (result) {
+          responses.push(result);
+        }
+      }
+    }
+
+    return responses;
+  }
+
+  apply(system: System<EventHookT>): void {
+    this.system = system;
+    this.system.on({
+      plugLoaded: (plug) => {
+        safeRun(async () => {
+          await this.dispatchEvent("plug:load", plug.name);
+        });
+      },
+    });
+  }
+
+  validateManifest(manifest: Manifest<EventHookT>): string[] {
+    const errors = [];
+    for (
+      const [_, functionDef] of Object.entries(
+        manifest.functions || {},
+      )
+    ) {
+      if (functionDef.events && !Array.isArray(functionDef.events)) {
+        errors.push("'events' key must be an array of strings");
+      }
+    }
+    return errors;
+  }
+}