@reventlessdev/reventless-local 3.0.0-alpha.173 → 3.0.0-alpha.175

package/src/adapter/Api/LocalEvents_Server.res.mjs

@@ -0,0 +1,341 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Ws from "ws";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as LocalAuth$ReventlessLocal from "../Auth/LocalAuth.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function pathSegment(s) {
+  return s.replace(/[^A-Za-z0-9-]/g, "-");
+}
+
+let clientChannelPrefix = "/client/";
+
+function channelMatches(subscription, channel) {
+  if (!subscription.endsWith("/*")) {
+    return subscription === channel;
+  }
+  let prefix = subscription.slice(0, subscription.length - 1 | 0);
+  return channel.startsWith(prefix);
+}
+
+let connections = {
+  contents: []
+};
+
+let nextConnectionId = {
+  contents: 0
+};
+
+function addConnection(send) {
+  nextConnectionId.contents = nextConnectionId.contents + 1 | 0;
+  let conn_id = nextConnectionId.contents;
+  let conn_subscriptions = {};
+  let conn = {
+    id: conn_id,
+    send: send,
+    subscriptions: conn_subscriptions
+  };
+  connections.contents.push(conn);
+  return conn;
+}
+
+function removeConnection(conn) {
+  connections.contents = connections.contents.filter(c => c.id !== conn.id);
+}
+
+function resetConnections() {
+  connections.contents = [];
+}
+
+function frame(fields) {
+  return JSON.stringify(Object.fromEntries(fields));
+}
+
+let connectionAckFrame = frame([
+  [
+    "type",
+    "connection_ack"
+  ],
+  [
+    "connectionTimeoutMs",
+    300000
+  ]
+]);
+
+function dataFrame(subscriptionId, event) {
+  return frame([
+    [
+      "type",
+      "data"
+    ],
+    [
+      "id",
+      subscriptionId
+    ],
+    [
+      "event",
+      event
+    ]
+  ]);
+}
+
+function broadcast(channel, event) {
+  connections.contents.forEach(conn => {
+    Object.entries(conn.subscriptions).forEach(param => {
+      if (channelMatches(param[1], channel)) {
+        return conn.send(dataFrame(param[0], event));
+      }
+    });
+  });
+}
+
+function broadcastStateChange(name, descriptor) {
+  let entityKey = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(descriptor), o => o["id"]), Stdlib_JSON.Decode.string), "");
+  if (entityKey === "") {
+    return;
+  }
+  let channel = `/default/` + pathSegment(name) + `/` + pathSegment(entityKey);
+  broadcast(channel, JSON.stringify(descriptor));
+}
+
+function decodeStringField(json, field) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[field]), Stdlib_JSON.Decode.string);
+}
+
+function handleFrame(conn, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (exn) {
+    parsed = undefined;
+  }
+  if (parsed === undefined) {
+    return;
+  }
+  let match = decodeStringField(parsed, "type");
+  if (match === undefined) {
+    return;
+  }
+  switch (match) {
+    case "connection_init" :
+      return conn.send(connectionAckFrame);
+    case "subscribe" :
+      let match$1 = decodeStringField(parsed, "id");
+      let match$2 = decodeStringField(parsed, "channel");
+      if (match$1 !== undefined && match$2 !== undefined) {
+        conn.subscriptions[match$1] = match$2;
+        return conn.send(frame([
+          [
+            "type",
+            "subscribe_success"
+          ],
+          [
+            "id",
+            match$1
+          ]
+        ]));
+      } else {
+        return;
+      }
+    case "unsubscribe" :
+      let id = decodeStringField(parsed, "id");
+      if (id !== undefined) {
+        Stdlib_Dict.$$delete(conn.subscriptions, id);
+        return conn.send(frame([
+          [
+            "type",
+            "unsubscribe_success"
+          ],
+          [
+            "id",
+            id
+          ]
+        ]));
+      } else {
+        return;
+      }
+    default:
+      return;
+  }
+}
+
+function stripBearer(token) {
+  if (token.startsWith("Bearer ")) {
+    return token.slice(7, token.length).trim();
+  } else {
+    return token.trim();
+  }
+}
+
+function tokenIsInvalid(token) {
+  if (token !== undefined) {
+    return Stdlib_Option.isNone(LocalAuth$ReventlessLocal.Login.verifyAndDecode(stripBearer(token)));
+  } else {
+    return false;
+  }
+}
+
+function authFromSubprotocolHeader(headerValue) {
+  return Stdlib_Option.flatMap(headerValue.split(",").map(prim => prim.trim()).find(p => p.startsWith("header-")), p => {
+    let blob = p.slice(7, p.length);
+    try {
+      return decodeStringField(JSON.parse(Buffer.from(blob, "base64url").toString("utf8")), "Authorization");
+    } catch (exn) {
+      return;
+    }
+  });
+}
+
+function jsonError(message) {
+  return Object.fromEntries([[
+      "error",
+      message
+    ]]);
+}
+
+function handlePublish(authorization, body) {
+  if (tokenIsInvalid(authorization)) {
+    return [
+      401,
+      jsonError("Invalid token")
+    ];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (exn) {
+    parsed = undefined;
+  }
+  if (parsed === undefined) {
+    return [
+      400,
+      jsonError("Invalid JSON body")
+    ];
+  }
+  let channel = decodeStringField(parsed, "channel");
+  let events = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(parsed), o => o["events"]), Stdlib_JSON.Decode.array);
+  if (channel === undefined) {
+    return [
+      400,
+      jsonError("Body must carry `channel` and a non-empty `events` array")
+    ];
+  }
+  if (events === undefined) {
+    return [
+      400,
+      jsonError("Body must carry `channel` and a non-empty `events` array")
+    ];
+  }
+  if (events.length === 0) {
+    return [
+      400,
+      jsonError("Body must carry `channel` and a non-empty `events` array")
+    ];
+  }
+  if (!channel.startsWith(clientChannelPrefix)) {
+    return [
+      403,
+      jsonError(`Clients may only publish under ` + clientChannelPrefix)
+    ];
+  }
+  let successful = [];
+  let failed = [];
+  events.forEach((event, index) => {
+    let entry = Object.fromEntries([[
+        "index",
+        index
+      ]]);
+    let s = Stdlib_JSON.Decode.string(event);
+    if (s !== undefined) {
+      let valid;
+      try {
+        JSON.parse(s);
+        valid = true;
+      } catch (exn) {
+        valid = false;
+      }
+      if (valid) {
+        broadcast(channel, s);
+        successful.push(entry);
+      } else {
+        failed.push(entry);
+      }
+      return;
+    }
+    failed.push(entry);
+  });
+  return [
+    200,
+    Object.fromEntries([
+      [
+        "successful",
+        successful
+      ],
+      [
+        "failed",
+        failed
+      ]
+    ])
+  ];
+}
+
+let realtimePath = "/events/realtime";
+
+let subprotocol = "aws-appsync-event-ws";
+
+function attach(server, port) {
+  let wss = new Ws.WebSocketServer({
+    server: server,
+    path: realtimePath,
+    handleProtocols: (_protocols, _req) => subprotocol
+  });
+  wss.on("connection", (ws, req) => {
+    let auth = Stdlib_Option.flatMap(req.headers["sec-websocket-protocol"], authFromSubprotocolHeader);
+    if (tokenIsInvalid(auth)) {
+      ws.close(4401, "Invalid token");
+      return;
+    }
+    let conn = addConnection(f => {
+      ws.send(f);
+    });
+    ws.on("message", data => handleFrame(conn, data.toString("utf8")));
+    ws.on("close", () => removeConnection(conn));
+  });
+  log.info("Events:Local", undefined, `events transport on ws://localhost:` + port.toString() + realtimePath + ` (publish: POST /events)`);
+}
+
+let YG;
+
+export {
+  YG,
+  log,
+  pathSegment,
+  clientChannelPrefix,
+  channelMatches,
+  connections,
+  nextConnectionId,
+  addConnection,
+  removeConnection,
+  resetConnections,
+  frame,
+  connectionAckFrame,
+  dataFrame,
+  broadcast,
+  broadcastStateChange,
+  decodeStringField,
+  handleFrame,
+  stripBearer,
+  tokenIsInvalid,
+  authFromSubprotocolHeader,
+  jsonError,
+  handlePublish,
+  realtimePath,
+  subprotocol,
+  attach,
+}
+/* log Not a pure module */

package/src/adapter/DomainGraphQL_Server.res

@@ -234,6 +234,26 @@ let _dispatch = (req: nodeRequest, res: nodeResponse, yoga: YG.yoga, getSdl: uni
     handleLogout(req, res)
   } else if path == uploadPresignPath && req.method == "POST" {
     handleUploadPresign(req, res)
+  } else if path == "/events" && req.method == "POST" {
+    // Local AppSync Events publish endpoint (`/client/**` only). The
+    // Authorization header carries the token raw (AWS Cognito-publish shape),
+    // so it bypasses `_isInvalidBearer` above and is verified inside.
+    let authorization = req.headers->Dict.get("authorization")
+    readBody(req, body => {
+      let (status, json) = LocalEvents_Server.handlePublish(~authorization, ~body)
+      _writeJson(res, ~status, json)
+    })
+  } else if path == "/events" && req.method == "OPTIONS" {
+    // Preflight for the cross-origin browser publish (Authorization header).
+    res->writeHead(
+      204,
+      {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST,OPTIONS",
+        "Access-Control-Allow-Headers": "*",
+      },
+    )
+    res->endEmpty
   } else if req.method == "OPTIONS" && LocalObjectStore.servedKey(path)->Option.isSome {
     // Preflight for the cross-origin browser PUT to a served-object path.
     res->writeHead(204, _corsWriteHeaders)
@@ -692,6 +712,9 @@ let start = (~port: int=4000, ~contextFactory as _: option<YG.contextFactory>=?,
   server->YG.listen(port, () =>
     log.info(~comp="GraphQL:Domain", `listening on http://localhost:${port->Int.toString}/graphql (SDL: /sdl)`)
   )
+  // Local AppSync Events transport (subscribe WS). Attached here so every
+  // start mode (split, unified, replay) carries it.
+  LocalEvents_Server.attach(~server, ~port)
   activeServer.contents = Some(server)
 }
 

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -19,6 +19,7 @@ import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/
 import * as LocalAuth$ReventlessLocal from "./Auth/LocalAuth.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as LocalObjectStore$ReventlessLocal from "./LocalObjectStore.res.mjs";
+import * as LocalEvents_Server$ReventlessLocal from "./Api/LocalEvents_Server.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -175,30 +176,50 @@ function _dispatch(req, res, yoga, getSdl) {
         "error",
         "Invalid bearer token"
       ]]));
-  } else if (path === "/sdl") {
+  }
+  if (path === "/sdl") {
     res.writeHead(200, {
       "Content-Type": "text/plain",
       "Access-Control-Allow-Origin": "*"
     });
     res.end(getSdl());
     return;
-  } else if (path === "/__inmemory/login" && req.method === "POST") {
+  }
+  if (path === "/__inmemory/login" && req.method === "POST") {
     return handleLogin(req, res);
-  } else if (path === "/__inmemory/logout" && req.method === "POST") {
+  }
+  if (path === "/__inmemory/logout" && req.method === "POST") {
     return handleLogout(req, res);
-  } else if (path === uploadPresignPath && req.method === "POST") {
+  }
+  if (path === uploadPresignPath && req.method === "POST") {
     return handleUploadPresign(req, res);
-  } else if (req.method === "OPTIONS" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
-    res.writeHead(204, _corsWriteHeaders);
-    res.end(null);
-    return;
-  } else if (req.method === "PUT" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
-    return handleObjectPut(req, res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
-  } else if (req.method === "GET" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
-    return handleObjectGet(res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
-  } else {
-    return yoga(req, res);
   }
+  if (path !== "/events" || req.method !== "POST") {
+    if (path === "/events" && req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST,OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      });
+      res.end(null);
+      return;
+    } else if (req.method === "OPTIONS" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+      res.writeHead(204, _corsWriteHeaders);
+      res.end(null);
+      return;
+    } else if (req.method === "PUT" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+      return handleObjectPut(req, res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
+    } else if (req.method === "GET" && Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.servedKey(path))) {
+      return handleObjectGet(res, Stdlib_Option.getOr(LocalObjectStore$ReventlessLocal.servedKey(path), ""));
+    } else {
+      return yoga(req, res);
+    }
+  }
+  let authorization = req.headers["authorization"];
+  readBody(req, body => {
+    let match = LocalEvents_Server$ReventlessLocal.handlePublish(authorization, body);
+    _writeJson(res, match[0], match[1]);
+  });
 }
 
 function encodeGlobalId(typeName, localId) {
@@ -572,6 +593,7 @@ function start(portOpt, param, param$1) {
     Stdlib_JsError.throwWithMessage(`DomainGraphQL_Server could not bind port ` + port.toString() + `: ` + detail);
   });
   server.listen(port, () => log.info("GraphQL:Domain", undefined, `listening on http://localhost:` + port.toString() + `/graphql (SDL: /sdl)`));
+  LocalEvents_Server$ReventlessLocal.attach(server, port);
   activeServer.contents = Primitive_option.some(server);
 }