alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/backend/api/GithubApi.js

@@ -1,3 +1,6 @@
+import {
+  pLimit
+} from "../../chunks/chunk-U5Z2VE7Z.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/GithubApi.ts
@@ -8,8 +11,11 @@ import {
   normalizeGithubSourceOptions
 } from "alinea/core/source/GithubSource";
 import { ShaMismatchError } from "alinea/core/source/ShaMismatchError";
+import { ReadonlyTree } from "alinea/core/source/Tree";
+import { assert } from "alinea/core/util/Assert";
 import { base64, btoa } from "alinea/core/util/Encoding";
 import { fileVersions } from "alinea/core/util/EntryFilenames";
+import { isRecord } from "alinea/core/util/Objects";
 import { join, relative } from "alinea/core/util/Paths";
 var GithubApi = class extends GithubSource {
   #options;
@@ -18,30 +24,46 @@ var GithubApi = class extends GithubSource {
     super(normalized);
     this.#options = normalized;
   }
-  async write(request) {
-    const currentCommit = await this.#getLatestCommitOid();
-    const currentSha = await this.shaAt(currentCommit);
+  write(request) {
+    return this.spending("save", () => this.#write(request));
+  }
+  /**
+   * Commit through GraphQL, which also answers the content sha before and
+   * after: a save spends none of the REST rate limit. A configured author
+   * commits through REST, writing only the commit there.
+   */
+  async #write(request) {
+    const current = await this.#getLatestCommit();
+    const currentSha = current.contentSha;
     if (currentSha !== request.fromSha)
       throw new ShaMismatchError(currentSha, request.fromSha);
     const { user } = request;
-    let commitMessage = request.description;
-    if (user?.name && user.email) {
-      commitMessage += `
+    let commitMessage = `${request.description}
 
+Alinea-Content: ${request.intoSha}`;
+    if (user?.name && user.email)
+      commitMessage += `
 Co-authored-by: ${user.name} <${user.email}>`;
-    }
-    const newCommit = await this.#applyChangesToRepo(
-      currentCommit,
+    const newCommit = this.#options.author ? await this.#commitThroughRest(
+      current,
+      request.changes,
+      commitMessage,
+      this.#options.author
+    ) : await this.#applyChangesToRepo(
+      current.oid,
       request.changes,
       commitMessage
     );
-    return { sha: await this.shaAt(newCommit) };
+    return { sha: newCommit.contentSha };
   }
-  async revisions(file) {
-    return this.#getFileCommitHistory(file);
+  revisions(file) {
+    return this.spending("history", () => this.#getFileCommitHistory(file));
   }
   async revisionData(file, revisionId) {
-    const content = await this.#getFileContentAtCommit(file, revisionId);
+    const content = await this.spending(
+      "revision",
+      () => this.#getFileContentAtCommit(file, revisionId)
+    );
     try {
       return content ? JSON.parse(content) : void 0;
     } catch (error) {
@@ -49,7 +71,7 @@ Co-authored-by: ${user.name} <${user.email}>`;
     }
   }
   async #graphQL(query, variables, token) {
-    return fetch("https://api.github.com/graphql", {
+    return this.githubFetch("https://api.github.com/graphql", {
       method: "POST",
       headers: {
         Authorization: `Bearer ${token}`,
@@ -60,9 +82,12 @@ Co-authored-by: ${user.name} <${user.email}>`;
       if (response.ok) return response.json();
       throw new HttpError(response.status, await response.text());
     }).then((result) => {
-      if (Array.isArray(result.errors) && result.errors.length > 0) {
-        const message = result.errors.map((e) => e.message).join("; ");
-        console.trace(result.errors);
+      const errors = Array.isArray(result.errors) ? result.errors.filter((error) => !isMissingFile(error)) : [];
+      if (errors.length > 0) {
+        const message = errors.map(
+          (error) => isRecord(error) && typeof error.message === "string" ? error.message : JSON.stringify(error)
+        ).join("; ");
+        console.trace(errors);
         throw new Error(message);
       }
       return result;
@@ -79,6 +104,7 @@ Co-authored-by: ${user.name} <${user.email}>`;
       if (requestCount === maxRequests) break;
       requestCount++;
       const versions = [...queue].filter((v) => !seen.has(v));
+      if (versions.length === 0) break;
       for (const v of versions) seen.add(v);
       queue.length = 0;
       const aliasMap = versions.map((v, idx) => ({
@@ -86,9 +112,10 @@ Co-authored-by: ${user.name} <${user.email}>`;
         version: v,
         path: join(rootDir, v)
       }));
+      const params = aliasMap.map(({ alias }) => `$${alias}: String!`).join(", ");
       const query = aliasMap.map(
-        ({ alias, path }) => `
-          ${alias}: history(path: "${path}", first: 100) {
+        ({ alias }) => `
+          ${alias}: history(path: $${alias}, first: 100) {
             nodes {
               oid
               committedDate
@@ -98,14 +125,16 @@ Co-authored-by: ${user.name} <${user.email}>`;
           }`
       ).join("");
       const gql = `
-        query GetFileHistory($owner: String!, $repo: String!, $branch: String!) {
+        query GetFileHistory($owner: String!, $repo: String!, $branch: String!, ${params}) {
           repository(owner: $owner, name: $repo) {
             ref(qualifiedName: $branch) {
               target { ... on Commit {${query}} }
             }
           }
         }`;
-      const result = await this.#graphQL(gql, { owner, repo, branch }, authToken);
+      const variables = { owner, repo, branch };
+      for (const { alias, path } of aliasMap) variables[alias] = path;
+      const result = await this.#graphQL(gql, variables, authToken);
       for (const { alias, version, path } of aliasMap) {
         const commits = result.data.repository.ref.target[alias]?.nodes || [];
         if (!commits.length) continue;
@@ -119,7 +148,7 @@ Co-authored-by: ${user.name} <${user.email}>`;
           }))
         );
         const earliest = commits[commits.length - 1].oid;
-        const res = await fetch(
+        const res = await this.githubFetch(
           `https://api.github.com/repos/${owner}/${repo}/commits/${earliest}`,
           { headers: { Authorization: `Bearer ${authToken}` } }
         );
@@ -157,10 +186,10 @@ Co-authored-by: ${user.name} <${user.email}>`;
     const { additions, deletions } = await this.#processChanges(changes);
     const { owner, repo, branch, authToken } = this.#options;
     return this.#graphQL(
-      `mutation CreateCommitOnBranch($input: CreateCommitOnBranchInput!) {
+      `mutation CreateCommitOnBranch($input: CreateCommitOnBranchInput!, $content: String!) {
       createCommitOnBranch(input: $input) {
         commit {
-          oid
+          ${commitStateFields}
         }
       }
     }`,
@@ -173,13 +202,11 @@ Co-authored-by: ${user.name} <${user.email}>`;
           message: { headline: commitMessage },
           fileChanges: { additions, deletions },
           expectedHeadOid
-        }
+        },
+        content: this.contentLocation
       },
       authToken
-    ).then((result) => {
-      const commitId = result.data.createCommitOnBranch.commit.oid;
-      return commitId;
-    }).catch((error) => {
+    ).then((result) => commitState(result.data.createCommitOnBranch.commit)).catch((error) => {
       if (error instanceof Error) {
         const mismatchMessage = /is at ([a-z0-9]+) but expected ([a-z0-9]+)/;
         const match = error.message.match(mismatchMessage);
@@ -203,56 +230,180 @@ Co-authored-by: ${user.name} <${user.email}>`;
       throw error;
     });
   }
+  /**
+   * Write a commit with its own author through the REST API: a tree on the
+   * current one, the commit, and the branch moved to it. Uploaded files are
+   * stored as blobs first, entries are passed in the tree as text.
+   */
+  async #commitThroughRest(parent, changes, commitMessage, author) {
+    const { branch } = this.#options;
+    if (!parent.treeOid)
+      throw new Error(`GitHub did not answer the tree of ${parent.oid}`);
+    const limit = pLimit(4);
+    let entries = await Promise.all(
+      changes.map((change) => limit(() => this.#treeEntry(change)))
+    );
+    const writeTree = () => this.#rest("POST", "git/trees", {
+      base_tree: parent.treeOid,
+      tree: entries
+    });
+    let tree;
+    try {
+      tree = await writeTree();
+    } catch (error) {
+      const removed = entries.filter((entry) => entry.sha === null);
+      if (!(error instanceof HttpError && error.code === 422) || !removed.length)
+        throw error;
+      const existing = await this.#existingPaths(
+        parent.oid,
+        removed.map((entry) => entry.path)
+      );
+      if (existing.size === removed.length) throw error;
+      entries = entries.filter(
+        (entry) => entry.sha !== null || existing.has(entry.path)
+      );
+      tree = await writeTree();
+    }
+    assert(isRecord(tree) && typeof tree.sha === "string");
+    const commit = await this.#rest("POST", "git/commits", {
+      message: commitMessage,
+      tree: tree.sha,
+      parents: [parent.oid],
+      author
+    });
+    assert(isRecord(commit) && typeof commit.sha === "string");
+    const ref = `git/refs/heads/${branch.split("/").map(encodeURIComponent).join("/")}`;
+    try {
+      await this.#rest("PATCH", ref, { sha: commit.sha, force: false });
+    } catch (error) {
+      if (error instanceof HttpError && error.code === 422 && /fast.forward/i.test(error.message))
+        throw new HttpError(409, error.message);
+      throw error;
+    }
+    return this.#getCommit(commit.sha);
+  }
+  /** The paths that exist in a commit. */
+  async #existingPaths(commit, paths) {
+    const { owner, repo, authToken } = this.#options;
+    const params = paths.map((_, i) => `$p${i}: String!`).join(", ");
+    const fields = paths.map((_, i) => `p${i}: object(expression: $p${i}) { oid }`).join("\n");
+    const variables = { owner, repo };
+    for (const [i, path] of paths.entries())
+      variables[`p${i}`] = `${commit}:${path}`;
+    const result = await this.#graphQL(
+      `query ExistingPaths($owner: String!, $repo: String!, ${params}) {
+      repository(owner: $owner, name: $repo) {
+        ${fields}
+      }
+    }`,
+      variables,
+      authToken
+    );
+    const repository = result.data.repository;
+    return new Set(paths.filter((_, i) => isRecord(repository[`p${i}`])));
+  }
+  async #treeEntry(change) {
+    const path = this.#changePath(change);
+    const mode = "100644";
+    switch (change.op) {
+      case "addContent":
+        return { path, mode, type: "blob", content: change.contents };
+      case "uploadFile": {
+        const blob = await this.#rest("POST", "git/blobs", {
+          content: await this.#fetchUploadedContent(change.url),
+          encoding: "base64"
+        });
+        assert(isRecord(blob) && typeof blob.sha === "string");
+        return { path, mode, type: "blob", sha: blob.sha };
+      }
+      case "deleteContent":
+      case "removeFile":
+        return { path, mode, type: "blob", sha: null };
+    }
+  }
+  /** The repository path a change writes or removes. */
+  #changePath(change) {
+    switch (change.op) {
+      case "addContent":
+      case "deleteContent":
+        return repositoryPath(this.contentLocation, change.path);
+      case "uploadFile":
+      case "removeFile":
+        return repositoryPath(this.#options.rootDir, change.location);
+    }
+  }
+  async #rest(method, path, body) {
+    const { owner, repo, authToken } = this.#options;
+    const response = await this.githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/${path}`,
+      {
+        method,
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!response.ok)
+      throw new HttpError(
+        response.status,
+        `GitHub ${method} ${path} failed: ${await response.text()}`
+      );
+    return response.json();
+  }
   async #processChanges(changes) {
-    const { rootDir } = this.#options;
     const additions = Array();
     const deletions = Array();
     for (const change of changes) {
+      const path = this.#changePath(change);
       switch (change.op) {
-        case "addContent": {
-          additions.push({
-            path: repositoryPath(this.contentLocation, change.path),
-            contents: btoa(change.contents)
-          });
+        case "addContent":
+          additions.push({ path, contents: btoa(change.contents) });
           break;
-        }
-        case "uploadFile": {
-          const file = repositoryPath(rootDir, change.location);
+        case "uploadFile":
           additions.push({
-            path: file,
+            path,
             contents: await this.#fetchUploadedContent(change.url)
           });
           break;
-        }
-        case "deleteContent": {
-          const file = repositoryPath(this.contentLocation, change.path);
-          deletions.push({ path: file });
-          break;
-        }
-        case "removeFile": {
-          const file = repositoryPath(rootDir, change.location);
-          deletions.push({ path: file });
+        case "deleteContent":
+        case "removeFile":
+          deletions.push({ path });
           break;
-        }
       }
     }
     return { additions, deletions };
   }
-  async #getLatestCommitOid() {
+  async #getLatestCommit() {
     const { owner, repo, branch, authToken } = this.#options;
     return this.#graphQL(
-      `query GetLatestCommit($owner: String!, $repo: String!, $branch: String!) {
+      `query GetLatestCommit($owner: String!, $repo: String!, $branch: String!, $content: String!) {
       repository(owner: $owner, name: $repo) {
         ref(qualifiedName: $branch) {
           target {
-            oid
+            ${commitStateFields}
           }
         }
       }
     }`,
-      { owner, repo, branch },
+      { owner, repo, branch, content: this.contentLocation },
       authToken
-    ).then((result) => result.data.repository.ref.target.oid);
+    ).then((result) => commitState(result.data.repository.ref.target));
+  }
+  async #getCommit(oid) {
+    const { owner, repo, authToken } = this.#options;
+    return this.#graphQL(
+      `query GetCommit($owner: String!, $repo: String!, $oid: GitObjectID!, $content: String!) {
+      repository(owner: $owner, name: $repo) {
+        object(oid: $oid) {
+          ${commitStateFields}
+        }
+      }
+    }`,
+      { owner, repo, oid, content: this.contentLocation },
+      authToken
+    ).then((result) => commitState(result.data.repository.object));
   }
   async #fetchUploadedContent(url) {
     const response = await fetch(url);
@@ -264,6 +415,18 @@ Co-authored-by: ${user.name} <${user.email}>`;
 function repositoryPath(...segments) {
   return relative("/", join("/", ...segments));
 }
+var commitStateFields = `oid ... on Commit { tree { oid } file(path: $content) { oid } }`;
+function commitState(commit) {
+  assert(isRecord(commit) && typeof commit.oid === "string");
+  const tree = commit.tree;
+  const treeOid = isRecord(tree) && typeof tree.oid === "string" ? tree.oid : void 0;
+  const file = commit.file;
+  const contentSha = isRecord(file) && typeof file.oid === "string" ? file.oid : ReadonlyTree.EMPTY.sha;
+  return { oid: commit.oid, treeOid, contentSha };
+}
+function isMissingFile(error) {
+  return isRecord(error) && error.type === "NOT_FOUND" && Array.isArray(error.path) && error.path.at(-1) === "file";
+}
 export {
   GithubApi
 };

package/dist/backend/api/OAuth2.js

@@ -1,15 +1,12 @@
 import {
   parse
 } from "../../chunks/chunk-BYJRQTFR.js";
-import {
-  PLazy
-} from "../../chunks/chunk-IKINPSS5.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/OAuth2.ts
 import { AuthResultType } from "alinea/cloud/AuthResult";
 import { Config } from "alinea/core/Config";
-import { HttpError } from "alinea/core/HttpError";
+import { ErrorCode, HttpError } from "alinea/core/HttpError";
 import { createId } from "alinea/core/Id";
 import { outcome } from "alinea/core/Outcome";
 import { assert } from "alinea/core/util/Assert";
@@ -459,6 +456,7 @@ import {
   MissingCredentialsError
 } from "../Auth.js";
 import { router } from "../router/Router.js";
+import { jwks } from "../util/JWKS.js";
 var COOKIE_VERIFIER = "alinea.cv";
 var COOKIE_ACCESS_TOKEN = "alinea.at";
 var COOKIE_REFRESH_TOKEN = "alinea.rt";
@@ -466,7 +464,7 @@ var OAuth2 = class {
   #context;
   #config;
   #client;
-  #jwks;
+  #jwksUri;
   #validateClaims;
   constructor(context, config, options) {
     assert(
@@ -489,19 +487,16 @@ var OAuth2 = class {
         return response;
       })
     });
-    const loadJwks = async () => {
-      try {
-        const res = await fetch(options.jwksUri);
-        if (res.status !== 200)
-          throw new HttpError(res.status, await res.text());
-        const jwks = await res.json();
-        return jwks.keys;
-      } catch (cause) {
-        this.#jwks = PLazy.from(loadJwks);
-        throw new Error("Remote unavailable", { cause });
-      }
-    };
-    this.#jwks = PLazy.from(loadJwks);
+    this.#jwksUri = options.jwksUri;
+  }
+  async #key(token) {
+    const { header } = decode(token);
+    const keys = await jwks(this.#jwksUri, header.kid).catch((cause) => {
+      throw new HttpError(ErrorCode.ServiceUnavailable, "Remote unavailable", {
+        cause
+      });
+    });
+    return selectKey(keys, header);
   }
   get #redirectUri() {
     const url = new URL(this.#context.handlerUrl);
@@ -612,11 +607,10 @@ var OAuth2 = class {
       [COOKIE_ACCESS_TOKEN]: accessToken,
       [COOKIE_REFRESH_TOKEN]: refreshToken
     } = parse(cookieHeader);
-    const jwks = await this.#jwks;
     try {
       if (!accessToken)
         throw new MissingCredentialsError("Missing access token cookie");
-      const key = selectKey(jwks, accessToken);
+      const key = await this.#key(accessToken);
       const user = await verify(accessToken, key);
       await this.#validateClaims(user);
       assert(user.exp, "Missing exp claim in access token");
@@ -626,13 +620,15 @@ var OAuth2 = class {
       return { ...ctx, user, token: accessToken };
     } catch (error) {
       if (!refreshToken) throw error;
+      if (error instanceof HttpError && error.code === ErrorCode.ServiceUnavailable)
+        throw error;
       const token = { accessToken, refreshToken, expiresAt: null };
       const newToken = await this.#client.refreshToken(token).catch((cause) => {
         throw new InvalidCredentialsError("Failed to refresh token", {
           cause: [cause, error]
         });
       });
-      const key = selectKey(jwks, newToken.accessToken);
+      const key = await this.#key(newToken.accessToken);
       const user = await verify(newToken.accessToken, key, {
         clockTolerance: 30
       }).catch((cause) => {
@@ -653,13 +649,12 @@ var OAuth2 = class {
     }
   }
 };
-function selectKey(jwks, token) {
-  const { header } = decode(token);
+function selectKey(jwks2, header) {
   const kid = header.kid;
   const alg = header.alg;
   if (!kid) {
-    if (jwks.length === 1) {
-      const key2 = jwks[0];
+    if (jwks2.length === 1) {
+      const key2 = jwks2[0];
       if (key2.alg && alg && key2.alg !== alg) {
         throw new Error(
           `Algorithm mismatch: token uses ${alg}, but key specifies ${key2.alg}`
@@ -671,7 +666,7 @@ function selectKey(jwks, token) {
       'Token is missing "kid" header, and JWKS contains multiple keys'
     );
   }
-  const key = jwks.find((k) => k.kid === kid);
+  const key = jwks2.find((k) => k.kid === kid);
   if (!key) throw new Error(`No key found for kid: ${kid}`);
   if (key.alg && alg && key.alg !== alg)
     throw new Error(

package/dist/backend/api/ProxyMedia.js

@@ -13,6 +13,9 @@ function proxyMediaUrl(request, source) {
     const value = request.headers.get(name);
     if (value) headers.set(name, value);
   }
+  const cookie = request.headers.get("cookie");
+  if (cookie && source.origin === new URL(request.url).origin)
+    headers.set("cookie", cookie);
   return fetch(source, {
     method: request.method,
     headers,

package/dist/backend/api/database.js

@@ -1,15 +1,15 @@
 import {
   driver_exports
-} from "../../chunks/chunk-QJGGYF6E.js";
-import "../../chunks/chunk-QSN6RH6X.js";
-import "../../chunks/chunk-ETWOY4AL.js";
-import "../../chunks/chunk-66YZ47TY.js";
-import "../../chunks/chunk-AIU6CMVT.js";
+} from "../../chunks/chunk-4ZA6KZHS.js";
+import "../../chunks/chunk-VA6NC3MI.js";
+import "../../chunks/chunk-A2I6MCCS.js";
+import "../../chunks/chunk-RAR44T5O.js";
+import "../../chunks/chunk-PTYZMV5G.js";
 import "../../chunks/chunk-N47Y62CI.js";
 import "../../chunks/chunk-QBPYWU6C.js";
 import "../../chunks/chunk-2BJ2IFQM.js";
 import "../../chunks/chunk-XCZXR3C2.js";
-import "../../chunks/chunk-MOWR65LM.js";
+import "../../chunks/chunk-PYDOMKJZ.js";
 import "../../chunks/chunk-76VMZTLN.js";
 import "../../chunks/chunk-2PIFHEYR.js";
 import "../../chunks/chunk-K62JP6HR.js";

package/dist/backend/store/GeneratedDatabase.js

@@ -12,8 +12,10 @@ async function createGeneratedDatabase(config, { database: db, fork, driver }) {
     includedAtBuild(filePath) {
       return initialTree?.has(filePath) ?? false;
     },
-    // Nothing reopens the in-memory writes: skip storing the synced tree.
-    recordsTree: false
+    // Nothing reopens the in-memory writes: skip storing the synced tree,
+    // and keep the statistics of the build instead of analyzing them.
+    recordsTree: false,
+    analyzes: false
   });
   try {
     await assertReadableData(db);

package/dist/backend/store/GeneratedDatabaseNode.d.ts

@@ -1,4 +1,8 @@
 import type { Config } from 'alinea/core/Config';
 import type { DatabaseOptions } from 'rado';
-/** Open the traced generated file as an in-memory overlay. */
+/**
+ * Open the traced generated file as an in-memory overlay. Every caller gets
+ * its own overlay: the CMS syncs its store through the handler, which syncs
+ * its own, so they must not share one or the CMS would wait for itself.
+ */
 export declare function generatedDatabase(config: Config, options?: DatabaseOptions): Promise<import("../../database/EntryStore.js").EntryStore>;

package/dist/backend/store/GeneratedDatabaseNode.js

@@ -5,30 +5,20 @@ import { runtimeDatabase } from "alinea/database/driver/RuntimeDatabase";
 import { fileURLToPath } from "node:url";
 import { createGeneratedDatabase } from "./GeneratedDatabase.js";
 async function generatedDatabasePath() {
+  const current = process.env.ALINEA_GENERATED_DATABASE;
+  if (current) return current;
   const { database } = await import("@alinea/generated/database.node.js");
   if (!(database instanceof URL))
     throw new Error("The generated database location is missing");
   return fileURLToPath(database);
 }
-var stores = /* @__PURE__ */ new WeakMap();
-var loggers = /* @__PURE__ */ new WeakMap();
-function generatedDatabase(config, options = {}) {
-  if (options.logQuery) loggers.set(config, options.logQuery);
-  let store = stores.get(config);
-  if (!store) {
-    store = generatedDatabasePath().then(
-      (path) => runtimeDatabase({
-        path,
-        overlay: true,
-        logQuery: (query, durationMs) => loggers.get(config)?.(query, durationMs)
-      })
-    ).then((db) => createGeneratedDatabase(config, db));
-    stores.set(config, store);
-    store.catch(() => {
-      if (stores.get(config) === store) stores.delete(config);
-    });
-  }
-  return store;
+async function generatedDatabase(config, options = {}) {
+  const db = await runtimeDatabase({
+    path: await generatedDatabasePath(),
+    overlay: true,
+    logQuery: options.logQuery
+  });
+  return createGeneratedDatabase(config, db);
 }
 export {
   generatedDatabase

package/dist/backend/store/GeneratedRelease.d.ts

@@ -1 +1 @@
-export declare const generatedRelease: Promise<string>;
+export declare function generatedRelease(): Promise<string>;

package/dist/backend/store/GeneratedRelease.js

@@ -1,10 +1,9 @@
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/store/GeneratedRelease.ts
-var generatedRelease = (
-  // @ts-ignore
-  import("@alinea/generated/release.js").then((module) => module.release)
-);
+function generatedRelease() {
+  return import("@alinea/generated/release.js").then((module) => module.release);
+}
 export {
   generatedRelease
 };

package/dist/backend/util/JWKS.d.ts

@@ -0,0 +1,4 @@
+export interface WebKey extends JsonWebKey {
+    kid: string;
+}
+export declare function jwks(uri: string, kid?: string): Promise<Array<WebKey>>;