@nxgt/janus-graphql 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,7 +1,3 @@
-// src/directives/apply.ts
-import { MapperKind, mapSchema } from "@graphql-tools/utils";
-import { defaultFieldResolver } from "graphql";
-
 // src/context.ts
 import {
   systemClock
@@ -38,14 +34,15 @@ function memoized(access) {
 // src/context.ts
 var checks = new WeakMap;
 var clocks = new WeakMap;
+var answers = new WeakMap;
 function createJanusContext(request, options) {
-  const { auth, access, type, clock } = options;
+  const { auth, access, type, clock, caller = "useJanus()" } = options;
   let answer;
   let asked = false;
   const authenticated = () => {
     if (!asked) {
       asked = true;
-      answer = request === undefined ? Promise.reject(new TypeError("useJanus(): the GraphQL context has no request to authenticate — build the context from an HTTP request")) : auth.authenticate(request, type === undefined ? undefined : { type });
+      answer = request === undefined ? Promise.reject(new TypeError(`${caller}: the GraphQL context has no request to authenticate — build the context from an HTTP request, or accept a graphql-ws connection with janusConnection().onConnect`)) : auth.authenticate(request, type === undefined ? undefined : { type });
     }
     return answer;
   };
@@ -63,8 +60,12 @@ function createJanusContext(request, options) {
   }
   if (clock !== undefined)
     clocks.set(janus, clock);
+  answers.set(janus, () => asked ? answer : undefined);
   return janus;
 }
+function answerOf(janus) {
+  return answers.get(janus)?.();
+}
 function clockOf(janus) {
   return clocks.get(janus) ?? systemClock;
 }
@@ -83,12 +84,118 @@ function janusOf(ctx, caller) {
   return janus;
 }
 
+// src/options.ts
+function checkWiring(caller, { auth, access, clock }) {
+  if (typeof auth?.authenticate !== "function") {
+    throw new TypeError(`${caller}: auth is not what janus() answered — pass { auth }`);
+  }
+  if (access !== undefined && typeof access?.can !== "function") {
+    throw new TypeError(`${caller}: access is not what permissions() answered — pass { auth, access }`);
+  }
+  if (clock !== undefined && typeof clock?.now !== "function") {
+    throw new TypeError(`${caller}: clock is not a Clock — pass the clock given to janus(), or leave it out for the system clock`);
+  }
+}
+
+// src/connection/credential.ts
+var BEARER = /^\s*bearer(?:\s|$)/i;
+function credentialOf(ctx, upgrade) {
+  const params = ctx.connectionParams;
+  if (params !== undefined && Object.hasOwn(params, "authorization")) {
+    const { authorization } = params;
+    if (typeof authorization !== "string")
+      return null;
+    if (BEARER.test(authorization))
+      return { authorization };
+  }
+  const request = upgrade === undefined ? ctx.extra?.request : upgrade(ctx);
+  return request ?? null;
+}
+var accepted = new WeakMap;
+function accept(ctx, credential) {
+  const { extra } = ctx;
+  if (typeof extra !== "object" || extra === null) {
+    throw new TypeError("janusConnection(): the connection's extra is not an object — pass the context graphql-ws gave onConnect");
+  }
+  accepted.set(extra, credential);
+}
+function acceptedOf(context) {
+  const extra = context?.extra;
+  if (typeof extra !== "object" || extra === null)
+    return;
+  return accepted.get(extra);
+}
+
+// src/connection/connection.ts
+function janusConnection(options) {
+  const { auth, access, type, clock } = options;
+  checkWiring("janusConnection()", { auth, access, clock });
+  if (options.upgrade !== undefined && typeof options.upgrade !== "function") {
+    throw new TypeError("janusConnection(): upgrade is not a function — pass (ctx) => the upgrade request, or leave it out to read ctx.extra.request");
+  }
+  const upgrade = options.upgrade?.bind(options);
+  const wiring = {
+    auth,
+    access,
+    type,
+    clock,
+    caller: "janusConnection().context"
+  };
+  return {
+    onConnect: async (ctx) => {
+      const credential = credentialOf(ctx, upgrade);
+      if (credential === null)
+        return false;
+      const current = await auth.authenticate(credential, type === undefined ? undefined : { type });
+      if (current === null)
+        return false;
+      accept(ctx, credential);
+      return true;
+    },
+    context: (ctx) => ({
+      janus: createJanusContext(acceptedOf(ctx), wiring)
+    })
+  };
+}
+// src/directives/apply.ts
+import { MapperKind, mapSchema } from "@graphql-tools/utils";
+import { defaultFieldResolver } from "graphql";
+
 // src/errors.ts
+import { JanusError as JanusError2, statusOf as statusOf2 } from "@nxgt/janus";
+import { GraphQLError as GraphQLError2 } from "graphql";
+
+// src/report.ts
 import { JanusError, statusOf } from "@nxgt/janus";
 import { GraphQLError } from "graphql";
+function janusErrorIn(error) {
+  let current = error;
+  while (current instanceof GraphQLError)
+    current = current.originalError;
+  return current instanceof JanusError ? current : null;
+}
+function reporting(report) {
+  const seen = new WeakSet;
+  return (error) => {
+    const janusError = janusErrorIn(error);
+    if (janusError === null || seen.has(janusError))
+      return;
+    if (statusOf(janusError.code) < 500)
+      return;
+    seen.add(janusError);
+    const warn = (failure) => process.emitWarning(`janusMaskError: report failed on ${janusError.code}: ${failure instanceof Error ? failure.name : typeof failure}`);
+    try {
+      Promise.resolve(report(janusError)).then(undefined, warn);
+    } catch (failure) {
+      warn(failure);
+    }
+  };
+}
+
+// src/errors.ts
 function denial(code, message) {
   const [status, fallback] = denialOf(code);
-  return new GraphQLError(message ?? fallback, {
+  return new GraphQLError2(message ?? fallback, {
     extensions: { code, http: { status } }
   });
 }
@@ -103,9 +210,9 @@ function denialOf(code) {
   }
 }
 function janusGraphQLError(error) {
-  const status = statusOf(error.code);
+  const status = statusOf2(error.code);
   const code = error.code === "STORE_FAILED" ? "SERVICE_UNAVAILABLE" : error.code;
-  return new GraphQLError(messageOf(status), {
+  return new GraphQLError2(messageOf(status), {
     originalError: error,
     extensions: { code, http: { status }, ...actionable(error) }
   });
@@ -142,14 +249,17 @@ function actionable(error) {
   }
 }
 function rethrown(error) {
-  throw error instanceof JanusError ? janusGraphQLError(error) : error;
+  throw error instanceof JanusError2 ? janusGraphQLError(error) : error;
 }
-function janusMaskError(fallback = masked) {
+function janusMaskError(options = {}) {
+  const { report, fallback = masked } = typeof options === "function" ? { fallback: options } : options;
+  const reported = report === undefined ? undefined : reporting(report);
   return (error, message, isDev) => {
-    const original = error instanceof GraphQLError ? error.originalError : error;
-    if (original instanceof JanusError) {
+    reported?.(error);
+    const original = error instanceof GraphQLError2 ? error.originalError : error;
+    if (original instanceof JanusError2) {
       const answer = janusGraphQLError(original);
-      return error instanceof GraphQLError ? new GraphQLError(answer.message, {
+      return error instanceof GraphQLError2 ? new GraphQLError2(answer.message, {
         nodes: error.nodes ?? null,
         path: error.path ?? null,
         originalError: original,
@@ -160,18 +270,18 @@ function janusMaskError(fallback = masked) {
   };
 }
 function masked(error, message) {
-  if (error instanceof GraphQLError) {
+  if (error instanceof GraphQLError2) {
     const original = error.originalError;
-    if (original === undefined || original instanceof GraphQLError) {
+    if (original === undefined || original instanceof GraphQLError2) {
       return error;
     }
-    return new GraphQLError(message, {
+    return new GraphQLError2(message, {
       nodes: error.nodes ?? null,
       path: error.path ?? null,
       extensions: { code: "INTERNAL_SERVER_ERROR" }
     });
   }
-  return new GraphQLError(message, {
+  return new GraphQLError2(message, {
     extensions: { code: "INTERNAL_SERVER_ERROR" }
   });
 }
@@ -625,28 +735,59 @@ async function can(ctx, permission, object, ...options) {
   const subject = await janus.user().then(undefined, rethrown);
   return check(subject, permission, object, options[0]).then(undefined, rethrown);
 }
+// src/renewal.ts
+var contexts = new WeakMap;
+function track(request, janus) {
+  const known = contexts.get(request);
+  if (known === undefined)
+    contexts.set(request, [janus]);
+  else
+    known.push(janus);
+}
+async function resendRenewed({ request, response }, cookie) {
+  const known = contexts.get(request);
+  if (cookie === undefined || known === undefined)
+    return;
+  for (const janus of known) {
+    const current = await answerOf(janus)?.then((answer) => answer, () => null);
+    if (current?.renewed === true && cookieOf(request, cookie.name) === current.token && !sets(response, cookie.name)) {
+      response.headers.append("Set-Cookie", cookie.serialize(current.token, current.session));
+    }
+  }
+}
+function cookieOf(request, name) {
+  const header = request.headers.get("cookie");
+  if (header === null)
+    return null;
+  for (const pair of header.split(";")) {
+    const at = pair.indexOf("=");
+    if (at !== -1 && pair.slice(0, at).trim() === name) {
+      return pair.slice(at + 1).trim();
+    }
+  }
+  return null;
+}
+function sets(response, name) {
+  return response.headers.getSetCookie().some((value) => value.startsWith(`${name}=`));
+}
+
 // src/plugin.ts
 function useJanus(options) {
   const { auth, access, type, clock, loaders, conditions } = options;
-  if (typeof auth?.authenticate !== "function") {
-    throw new TypeError("useJanus(): auth is not what janus() answered — pass { auth }");
-  }
-  if (access !== undefined && typeof access?.can !== "function") {
-    throw new TypeError("useJanus(): access is not what permissions() answered — pass { auth, access }");
-  }
-  if (clock !== undefined && typeof clock?.now !== "function") {
-    throw new TypeError("useJanus(): clock is not a Clock — pass the clock given to janus(), or leave it out for the system clock");
-  }
+  checkWiring("useJanus()", { auth, access, clock });
   const applied = new WeakSet;
   return {
     onContextBuilding: ({ context, extendContext }) => {
       const { request } = context;
-      const janus = createJanusContext(request, {
+      const janus = createJanusContext(request ?? acceptedOf(context), {
         auth,
         access,
         type,
         clock
       });
+      if (typeof request === "object" && request !== null) {
+        track(request, janus);
+      }
       extendContext({ janus });
     },
     onSchemaChange: ({ schema, replaceSchema }) => {
@@ -661,7 +802,8 @@ function useJanus(options) {
       });
       applied.add(next);
       replaceSchema(next);
-    }
+    },
+    onResponse: (payload) => resendRenewed(payload, auth.cookie)
   };
 }
 // src/sdl.ts
@@ -714,6 +856,7 @@ export {
   applyJanusDirectives,
   can,
   denial,
+  janusConnection,
   janusGraphQLError,
   janusMaskError,
   janusTypeDefs,
@@ -722,5 +865,5 @@ export {
   useJanus
 };
 
-//# debugId=50FC1B1149A482D964756E2164756E21
+//# debugId=33AAA17AADE0081364756E2164756E21
 //# sourceMappingURL=index.js.map