@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -0,0 +1,576 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Http from "http";
+import * as Graphql from "graphql";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as GraphqlYoga from "graphql-yoga";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+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 Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function readBody(req, onBody) {
+  let buf = {
+    contents: ""
+  };
+  req.setEncoding("utf8");
+  req.on("data", chunk => {
+    buf.contents = buf.contents + chunk;
+  });
+  req.on("end", () => onBody(buf.contents));
+}
+
+function _writeJson(res, status, body) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(body));
+}
+
+function _loginRejected(res, error) {
+  _writeJson(res, 401, Object.fromEntries([[
+      "error",
+      error
+    ]]));
+}
+
+function handleLogin(req, res) {
+  readBody(req, body => {
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch (exn) {
+      parsed = undefined;
+    }
+    if (parsed === undefined) {
+      return _loginRejected(res, "Invalid JSON body");
+    }
+    let username = parsed.username;
+    LocalAuth$ReventlessLocal.Login.issue(username, parsed.password).then(result => {
+      if (result.TAG === "Ok") {
+        let i = LocalAuth$ReventlessLocal.lookupUser(username);
+        let identity = i !== undefined ? i : Identity$Reventless.anonymous;
+        let identityJson = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
+        _writeJson(res, 200, Object.fromEntries([
+          [
+            "token",
+            result._0
+          ],
+          [
+            "identity",
+            identityJson
+          ]
+        ]));
+      } else {
+        _loginRejected(res, result._0);
+      }
+      return Promise.resolve();
+    });
+  });
+}
+
+function handleLogout(_req, res) {
+  res.writeHead(204, {
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(null);
+}
+
+function _isInvalidBearer(req) {
+  let h = req.headers["authorization"];
+  if (h === undefined) {
+    return false;
+  }
+  if (!h.startsWith("Bearer ")) {
+    return false;
+  }
+  let token = h.slice(7, h.length).trim();
+  return Stdlib_Option.isNone(LocalAuth$ReventlessLocal.Login.verifyAndDecode(token));
+}
+
+function _dispatch(req, res, yoga, getSdl) {
+  let path = Stdlib_Option.getOr(req.url.split("?")[0], req.url);
+  if (path !== "/__inmemory/login" && _isInvalidBearer(req)) {
+    return _writeJson(res, 401, Object.fromEntries([[
+        "error",
+        "Invalid bearer token"
+      ]]));
+  } else 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") {
+    return handleLogin(req, res);
+  } else if (path === "/__inmemory/logout" && req.method === "POST") {
+    return handleLogout(req, res);
+  } else {
+    return yoga(req, res);
+  }
+}
+
+function encodeGlobalId(typeName, localId) {
+  return btoa(typeName + `:` + localId);
+}
+
+function decodeGlobalId(globalId) {
+  try {
+    let decoded = atob(globalId);
+    let idx = decoded.indexOf(":");
+    if (idx <= 0) {
+      return;
+    }
+    let typeName = decoded.slice(0, idx);
+    let localId = decoded.slice(idx + 1 | 0, decoded.length);
+    return [
+      typeName,
+      localId
+    ];
+  } catch (exn) {
+    return;
+  }
+}
+
+let mutationResolvers = {
+  contents: {}
+};
+
+let queryResolvers = {
+  contents: {}
+};
+
+let subscriptionResolvers = {
+  contents: {}
+};
+
+let mutationFields = {
+  contents: []
+};
+
+let queryFields = {
+  contents: []
+};
+
+let subscriptionFields = {
+  contents: []
+};
+
+let typeDefinitions = {
+  contents: []
+};
+
+function registerMutations(sdlFields, resolvers) {
+  mutationFields.contents = mutationFields.contents.concat(sdlFields);
+  Object.entries(resolvers).forEach(param => {
+    mutationResolvers.contents[param[0]] = param[1];
+  });
+}
+
+function registerQueries(sdlFields, resolvers) {
+  queryFields.contents = queryFields.contents.concat(sdlFields);
+  Object.entries(resolvers).forEach(param => {
+    queryResolvers.contents[param[0]] = param[1];
+  });
+}
+
+function registerSubscriptions(sdlFields, resolvers) {
+  subscriptionFields.contents = subscriptionFields.contents.concat(sdlFields);
+  Object.entries(resolvers).forEach(param => {
+    subscriptionResolvers.contents[param[0]] = param[1];
+  });
+}
+
+function getMutationResolver(fieldName) {
+  return mutationResolvers.contents[fieldName];
+}
+
+function getQueryResolver(fieldName) {
+  return queryResolvers.contents[fieldName];
+}
+
+function registerTypes(sdlTypes) {
+  typeDefinitions.contents = typeDefinitions.contents.concat(sdlTypes);
+}
+
+let nodeTypeRegistry = {
+  contents: {}
+};
+
+function registerNodeType(typeName, queryDbName) {
+  nodeTypeRegistry.contents[typeName] = queryDbName;
+}
+
+let nodeResolverCallback = {
+  contents: undefined
+};
+
+function registerNodeResolverCallback(cb) {
+  nodeResolverCallback.contents = cb;
+}
+
+function buildNodeResolver() {
+  let resolve = nodeResolverCallback.contents;
+  if (resolve === undefined) {
+    return;
+  }
+  let resolver = async (_root, args, _ctx) => {
+    let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["id"]), Stdlib_JSON.Decode.string), "");
+    let match = decodeGlobalId(id);
+    if (match === undefined) {
+      return null;
+    }
+    let entity = await resolve(match[0], match[1]);
+    if (entity !== undefined) {
+      return entity;
+    } else {
+      return null;
+    }
+  };
+  return [
+    "node",
+    resolver
+  ];
+}
+
+let debug = Stdlib_Option.isSome(process.env["GRAPHQL_DEBUG"]);
+
+let activeServer = {
+  contents: undefined
+};
+
+let activeSchema = {
+  contents: undefined
+};
+
+let lastFullSdl = {
+  contents: undefined
+};
+
+function buildSdl() {
+  let typesSdl = typeDefinitions.contents.length !== 0 ? typeDefinitions.contents.join("\n\n") : "";
+  let mutations = mutationFields.contents.length !== 0 ? mutationFields.contents.join("\n") : "  _noop: String";
+  let queries = queryFields.contents.length !== 0 ? queryFields.contents.join("\n") : "  _noop: String";
+  let queriesMutationsSdl = `type Query {
+` + queries + `
+}
+type Mutation {
+` + mutations + `
+}`;
+  let subscriptionsSdl = subscriptionFields.contents.length !== 0 ? `\n\ntype Subscription {\n` + subscriptionFields.contents.join("\n") + `\n}` : "";
+  let base = typesSdl.length > 0 ? typesSdl + "\n\n" + queriesMutationsSdl : queriesMutationsSdl;
+  return base + subscriptionsSdl;
+}
+
+function start(portOpt, param, param$1) {
+  let port = portOpt !== undefined ? portOpt : 4000;
+  let match = buildNodeResolver();
+  if (match !== undefined) {
+    queryResolvers.contents[match[0]] = match[1];
+  }
+  let resolvers = {};
+  resolvers["Query"] = queryResolvers.contents;
+  resolvers["Mutation"] = mutationResolvers.contents;
+  if (Object.keys(subscriptionResolvers.contents).length !== 0) {
+    resolvers["Subscription"] = subscriptionResolvers.contents;
+  }
+  let sdl = buildSdl();
+  lastFullSdl.contents = sdl;
+  let schema = GraphqlYoga.createSchema({
+    typeDefs: sdl,
+    resolvers: resolvers
+  });
+  activeSchema.contents = Primitive_option.some(schema);
+  let yoga = GraphqlYoga.createYoga({
+    schema: schema,
+    graphiql: true,
+    logging: debug,
+    maskedErrors: !debug,
+    context: Auth_GraphqlContext$ReventlessLocal.buildAuthContext
+  });
+  let getSdl = () => {
+    let s = activeSchema.contents;
+    if (s !== undefined) {
+      return Graphql.printSchema(Primitive_option.valFromOption(s));
+    } else {
+      return Stdlib_Option.getOr(lastFullSdl.contents, "");
+    }
+  };
+  let server = Http.createServer((req, res) => _dispatch(req, res, yoga, getSdl));
+  server.listen(port, () => log.info("GraphQL:Domain", undefined, `listening on http://localhost:` + port.toString() + `/graphql (SDL: /sdl)`));
+  activeServer.contents = Primitive_option.some(server);
+}
+
+function stop() {
+  let server = activeServer.contents;
+  if (server !== undefined) {
+    Primitive_option.valFromOption(server).close(() => {});
+    activeServer.contents = undefined;
+    activeSchema.contents = undefined;
+    return;
+  }
+}
+
+function rebuildSchema(baseFragment, pluginFragments) {
+  stop();
+  let allFragments = [baseFragment].concat(pluginFragments);
+  let fragmentTypes = allFragments.flatMap(frag => GraphQL_Stitcher$ReventlessCore.decode(frag).types);
+  let existingNames = new Set(typeDefinitions.contents.map(GraphQL_Stitcher$ReventlessCore.extractLeadingName));
+  fragmentTypes.forEach(typeDef => {
+    let name = GraphQL_Stitcher$ReventlessCore.extractLeadingName(typeDef);
+    if (!existingNames.has(name)) {
+      typeDefinitions.contents.push(typeDef);
+      existingNames.add(name);
+      return;
+    }
+  });
+  let match = buildNodeResolver();
+  if (match !== undefined) {
+    queryResolvers.contents[match[0]] = match[1];
+  }
+  let fullSdl = buildSdl();
+  lastFullSdl.contents = fullSdl;
+  let resolvers = {};
+  resolvers["Query"] = queryResolvers.contents;
+  resolvers["Mutation"] = mutationResolvers.contents;
+  if (Object.keys(subscriptionResolvers.contents).length !== 0) {
+    resolvers["Subscription"] = subscriptionResolvers.contents;
+  }
+  let schema = GraphqlYoga.createSchema({
+    typeDefs: fullSdl,
+    resolvers: resolvers
+  });
+  activeSchema.contents = Primitive_option.some(schema);
+  let yoga = GraphqlYoga.createYoga({
+    schema: schema,
+    graphiql: true,
+    logging: debug,
+    maskedErrors: !debug,
+    context: Auth_GraphqlContext$ReventlessLocal.buildAuthContext
+  });
+  let getSdl = () => {
+    let s = activeSchema.contents;
+    if (s !== undefined) {
+      return Graphql.printSchema(Primitive_option.valFromOption(s));
+    } else {
+      return Stdlib_Option.getOr(lastFullSdl.contents, "");
+    }
+  };
+  let server = Http.createServer((req, res) => _dispatch(req, res, yoga, getSdl));
+  server.listen(4000, () => log.info("GraphQL:Domain", undefined, "rebuilt schema - http://localhost:4000/graphql (SDL: /sdl)"));
+  activeServer.contents = Primitive_option.some(server);
+}
+
+function reset() {
+  mutationResolvers.contents = {};
+  queryResolvers.contents = {};
+  subscriptionResolvers.contents = {};
+  mutationFields.contents = [];
+  queryFields.contents = [];
+  subscriptionFields.contents = [];
+  typeDefinitions.contents = [];
+  nodeTypeRegistry.contents = {};
+  nodeResolverCallback.contents = undefined;
+  activeSchema.contents = undefined;
+  lastFullSdl.contents = undefined;
+}
+
+function getRegisteredSdl() {
+  return buildSdl();
+}
+
+function getRegisteredResolverNames() {
+  return {
+    mutations: Object.keys(mutationResolvers.contents),
+    queries: Object.keys(queryResolvers.contents)
+  };
+}
+
+function getFullSdl() {
+  return lastFullSdl.contents;
+}
+
+function getSchema() {
+  return activeSchema.contents;
+}
+
+function getLiveSdl() {
+  return Stdlib_Option.map(activeSchema.contents, prim => Graphql.printSchema(prim));
+}
+
+function printLiveSdl() {
+  let sdl = getLiveSdl();
+  if (sdl !== undefined) {
+    log.info("GraphQL:Domain", undefined, "Live SDL:");
+    console.log(sdl);
+    return;
+  } else {
+    return log.info("GraphQL:Domain", undefined, "no active schema");
+  }
+}
+
+function extractFieldName(sdlField) {
+  let trimmed = sdlField.trim();
+  return Stdlib_Option.getOr(Stdlib_Option.getOr(trimmed.split("(")[0], "").trim().split(":")[0], "").trim();
+}
+
+function diagnostics() {
+  let mutFieldNames = mutationFields.contents.map(extractFieldName).filter(n => n !== "_noop");
+  let queryFieldNames = queryFields.contents.map(extractFieldName).filter(n => n !== "_noop");
+  let mutResolverNames = Object.keys(mutationResolvers.contents);
+  let queryResolverNames = Object.keys(queryResolvers.contents);
+  let mismatches = [];
+  let mutResolverSet = new Set(mutResolverNames);
+  mutFieldNames.forEach(name => {
+    if (!mutResolverSet.has(name)) {
+      mismatches.push(`Mutation "` + name + `": SDL field but no resolver`);
+      return;
+    }
+  });
+  let queryResolverSet = new Set(queryResolverNames);
+  queryFieldNames.forEach(name => {
+    if (!queryResolverSet.has(name)) {
+      mismatches.push(`Query "` + name + `": SDL field but no resolver`);
+      return;
+    }
+  });
+  let mutFieldSet = new Set(mutFieldNames);
+  mutResolverNames.forEach(name => {
+    if (!mutFieldSet.has(name)) {
+      mismatches.push(`Mutation "` + name + `": resolver but no SDL field`);
+      return;
+    }
+  });
+  let queryFieldSet = new Set(queryFieldNames);
+  queryResolverNames.forEach(name => {
+    if (!queryFieldSet.has(name)) {
+      mismatches.push(`Query "` + name + `": resolver but no SDL field`);
+      return;
+    }
+  });
+  let typeNames = typeDefinitions.contents.map(GraphQL_Stitcher$ReventlessCore.extractLeadingName);
+  return {
+    registeredTypeDefinitions: typeNames,
+    registeredMutationFields: mutFieldNames,
+    registeredQueryFields: queryFieldNames,
+    registeredMutationResolvers: mutResolverNames,
+    registeredQueryResolvers: queryResolverNames,
+    typeCount: typeNames.length,
+    sdlMutationCount: mutFieldNames.length,
+    sdlQueryCount: queryFieldNames.length,
+    resolverMutationCount: mutResolverNames.length,
+    resolverQueryCount: queryResolverNames.length,
+    mismatches: mismatches,
+    fullSdl: lastFullSdl.contents,
+    serverRunning: Stdlib_Option.isSome(activeServer.contents)
+  };
+}
+
+function printDiagnostics() {
+  let p = s => log.info("GraphQL:Domain", undefined, s);
+  let d = diagnostics();
+  p("Diagnostics");
+  p(`  Types: ` + d.typeCount.toString());
+  p(`  Mutations: ` + d.sdlMutationCount.toString() + ` SDL fields, ` + d.resolverMutationCount.toString() + ` resolvers`);
+  p(`  Queries: ` + d.sdlQueryCount.toString() + ` SDL fields, ` + d.resolverQueryCount.toString() + ` resolvers`);
+  if (d.mismatches.length !== 0) {
+    p(`  Mismatches (` + d.mismatches.length.toString() + `):`);
+    d.mismatches.forEach(m => p(`    ⚠ ` + m));
+  } else {
+    p("  No mismatches");
+  }
+  p(`  Server running: ` + (
+    d.serverRunning ? "yes" : "no"
+  ));
+  let sdl = d.fullSdl;
+  if (sdl !== undefined) {
+    p("");
+    p("--- Full SDL ---");
+    sdl.split("\n").forEach(p);
+    return p("--- End ---");
+  } else {
+    return p("  No SDL recorded");
+  }
+}
+
+let asInterface = {
+  registerMutations: registerMutations,
+  registerQueries: registerQueries,
+  registerSubscriptions: registerSubscriptions,
+  registerTypes: registerTypes,
+  getMutationResolver: getMutationResolver,
+  getQueryResolver: getQueryResolver,
+  start: start,
+  stop: stop,
+  reset: reset,
+  buildSdl: buildSdl,
+  getFullSdl: getFullSdl,
+  getSchema: getSchema,
+  diagnostics: diagnostics,
+  printDiagnostics: printDiagnostics
+};
+
+let YG;
+
+let buildAuthContext = Auth_GraphqlContext$ReventlessLocal.buildAuthContext;
+
+export {
+  YG,
+  log,
+  readBody,
+  _writeJson,
+  _loginRejected,
+  handleLogin,
+  handleLogout,
+  _isInvalidBearer,
+  _dispatch,
+  buildAuthContext,
+  encodeGlobalId,
+  decodeGlobalId,
+  mutationResolvers,
+  queryResolvers,
+  subscriptionResolvers,
+  mutationFields,
+  queryFields,
+  subscriptionFields,
+  typeDefinitions,
+  registerMutations,
+  registerQueries,
+  registerSubscriptions,
+  getMutationResolver,
+  getQueryResolver,
+  registerTypes,
+  nodeTypeRegistry,
+  registerNodeType,
+  nodeResolverCallback,
+  registerNodeResolverCallback,
+  buildNodeResolver,
+  debug,
+  activeServer,
+  activeSchema,
+  lastFullSdl,
+  buildSdl,
+  start,
+  stop,
+  rebuildSchema,
+  reset,
+  getRegisteredSdl,
+  getRegisteredResolverNames,
+  getFullSdl,
+  getSchema,
+  getLiveSdl,
+  printLiveSdl,
+  extractFieldName,
+  diagnostics,
+  printDiagnostics,
+  asInterface,
+}
+/* log Not a pure module */