@atproto/xrpc-server 0.4.2 → 0.4.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atproto/xrpc-server
 
+## 0.4.3
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atproto/lexicon@0.3.2
+
 ## 0.4.2
 
 ### Patch Changes

package/LICENSE.txt

@@ -1,6 +1,6 @@
 Dual MIT/Apache-2.0 License
 
-Copyright (c) 2022-2023 Bluesky PBC, and Contributors
+Copyright (c) 2022-2024 Bluesky PBC, and Contributors
 
 Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
 

package/dist/auth.d.ts

@@ -1,10 +1,10 @@
 import * as crypto from '@atproto/crypto';
-declare type ServiceJwtPayload = {
+type ServiceJwtPayload = {
     iss: string;
     aud: string;
     exp?: number;
 };
-declare type ServiceJwtParams = ServiceJwtPayload & {
+type ServiceJwtParams = ServiceJwtPayload & {
     keypair: crypto.Keypair;
 };
 export declare const createServiceJwt: (params: ServiceJwtParams) => Promise<string>;

package/dist/index.js

@@ -9551,30 +9551,292 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js"(exports, module2) {
+    "use strict";
+    var isLinux = () => process.platform === "linux";
+    var report = null;
+    var getReport = () => {
+      if (!report) {
+        report = isLinux() && process.report ? process.report.getReport() : {};
+      }
+      return report;
+    };
+    module2.exports = { isLinux, getReport };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
+    "use strict";
+    var fs = require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var readFileSync = (path) => fs.readFileSync(path, "utf-8");
+    var readFile = (path) => new Promise((resolve, reject) => {
+      fs.readFile(path, "utf-8", (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+    module2.exports = {
+      LDD_PATH,
+      readFileSync,
+      readFile
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js"(exports, module2) {
+    "use strict";
+    var childProcess = require("child_process");
+    var { isLinux, getReport } = require_process();
+    var { LDD_PATH, readFile, readFileSync } = require_filesystem();
+    var cachedFamilyFilesystem;
+    var cachedVersionFilesystem;
+    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+    var commandOut = "";
+    var safeCommand = () => {
+      if (!commandOut) {
+        return new Promise((resolve) => {
+          childProcess.exec(command, (err, out) => {
+            commandOut = err ? " " : out;
+            resolve(commandOut);
+          });
+        });
+      }
+      return commandOut;
+    };
+    var safeCommandSync = () => {
+      if (!commandOut) {
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch (_err) {
+          commandOut = " ";
+        }
+      }
+      return commandOut;
+    };
+    var GLIBC = "glibc";
+    var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
+    var MUSL = "musl";
+    var GLIBC_ON_LDD = GLIBC.toUpperCase();
+    var MUSL_ON_LDD = MUSL.toLowerCase();
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var familyFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return GLIBC;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return MUSL;
+        }
+      }
+      return null;
+    };
+    var familyFromCommand = (out) => {
+      const [getconf, ldd1] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return GLIBC;
+      }
+      if (ldd1 && ldd1.includes(MUSL)) {
+        return MUSL;
+      }
+      return null;
+    };
+    var getFamilyFromLddContent = (content) => {
+      if (content.includes(MUSL_ON_LDD)) {
+        return MUSL;
+      }
+      if (content.includes(GLIBC_ON_LDD)) {
+        return GLIBC;
+      }
+      return null;
+    };
+    var familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var family = async () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var familySync = () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+    var versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return report.header.glibcVersionRuntime;
+      }
+      return null;
+    };
+    var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+    var versionFromCommand = (out) => {
+      const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return versionSuffix(getconf);
+      }
+      if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+        return versionSuffix(ldd2);
+      }
+      return null;
+    };
+    var version2 = async () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = await versionFromFilesystem();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = await safeCommand();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    var versionSync = () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = versionFromFilesystemSync();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = safeCommandSync();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    module2.exports = {
+      GLIBC,
+      MUSL,
+      family,
+      familySync,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version: version2,
+      versionSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js
 var require_node_gyp_build_optional_packages = __commonJS({
-  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
     var fs = require("fs");
     var path = require("path");
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    var url = require("url");
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
-    var abi = process.versions.modules;
+    var versions = process.versions;
+    var abi = versions.modules;
+    if (versions.deno || process.isBun) {
+      abi = "unsupported";
+    }
     var runtime = isElectron() ? "electron" : "node";
     var arch = process.arch;
     var platform = process.platform;
-    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
-    var uv = (process.versions.uv || "").split(".")[0];
+    var uv = (versions.uv || "").split(".")[0];
     module2.exports = load;
     function load(dir) {
-      return runtimeRequire(load.path(dir));
+      if (typeof __webpack_require__ === "function")
+        return __non_webpack_require__(load.path(dir));
+      else
+        return require(load.path(dir));
     }
     load.path = function(dir) {
       dir = path.resolve(dir || ".");
-      var packageName;
+      var packageName = "";
       try {
-        packageName = runtimeRequire(path.join(dir, "package.json")).name;
+        if (typeof __webpack_require__ === "function")
+          packageName = __non_webpack_require__(path.join(dir, "package.json")).name;
+        else
+          packageName = require(path.join(dir, "package.json")).name;
         var varName = packageName.toUpperCase().replace(/-/g, "_") + "_PREBUILD";
         if (process.env[varName])
           dir = process.env[varName];
@@ -9596,7 +9858,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return nearby;
       var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
       try {
-        var prebuildPackage = path.dirname(require("module").createRequire(path.join(dir, "package.json")).resolve(platformPackage));
+        var prebuildPackage = path.dirname(require("module").createRequire(url.pathToFileURL(path.join(dir, "package.json"))).resolve(platformPackage));
         return resolveFile(prebuildPackage);
       } catch (error) {
       }
@@ -9612,7 +9874,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         process.versions.electron ? "electron=" + process.versions.electron : "",
         typeof __webpack_require__ === "function" ? "webpack=true" : ""
       ].filter(Boolean).join(" ");
-      throw new Error("No native build was found for " + target2 + "\n    loaded from: " + dir + " and package: " + platformPackage + "\n");
+      throw new Error("No native build was found for " + target2 + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
       function resolve(dir2) {
         var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
@@ -9735,8 +9997,11 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return true;
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
-    function isAlpine(platform2) {
-      return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
+    function isMusl(platform2) {
+      if (platform2 !== "linux")
+        return false;
+      const { familySync, MUSL } = require_detect_libc();
+      return familySync() === MUSL;
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -9747,9 +10012,9 @@ var require_node_gyp_build_optional_packages = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js
+// ../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js
 var require_cbor_extract = __commonJS({
-  "../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js"(exports, module2) {
     module2.exports = require_node_gyp_build_optional_packages()(__dirname);
   }
 });
@@ -28171,7 +28436,7 @@ var require_object_inspect = __commonJS({
       if (isBoolean(obj)) {
         return markBoxed(booleanValueOf.call(obj));
       }
-      if (isString(obj)) {
+      if (isString2(obj)) {
         return markBoxed(inspect(String(obj)));
       }
       if (!isDate(obj) && !isRegExp(obj)) {
@@ -28210,7 +28475,7 @@ var require_object_inspect = __commonJS({
     function isError(obj) {
       return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
     }
-    function isString(obj) {
+    function isString2(obj) {
       return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
     }
     function isNumber(obj) {
@@ -39777,6 +40042,7 @@ __export(src_exports5, {
   handlerAuth: () => handlerAuth,
   handlerError: () => handlerError,
   handlerInput: () => handlerInput,
+  handlerPipeThrough: () => handlerPipeThrough,
   handlerSuccess: () => handlerSuccess,
   isHandlerError: () => isHandlerError,
   isShared: () => isShared,
@@ -46270,6 +46536,11 @@ var handlerSuccess = z.object({
   body: z.any(),
   headers: z.record(z.string()).optional()
 });
+var handlerPipeThrough = z.object({
+  encoding: z.string(),
+  buffer: z.instanceof(ArrayBuffer),
+  headers: z.record(z.string()).optional()
+});
 var handlerError = z.object({
   status: z.number(),
   error: z.string().optional(),
@@ -52574,7 +52845,7 @@ function validateInput(nsid2, def2, req, opts, lexicons) {
   if (req.readableEnded) {
     body = req.body;
   } else {
-    body = decodeBodyStream(req, opts.payload?.blobLimit);
+    body = decodeBodyStream(req, opts.blobLimit);
   }
   return {
     encoding: inputEncoding,
@@ -52720,6 +52991,9 @@ var RateLimiter = class {
       return null;
     }
     const key = opts?.calcKey ? opts.calcKey(ctx) : this.calcKey(ctx);
+    if (key === null) {
+      return null;
+    }
     const points = opts?.calcPoints ? opts.calcPoints(ctx) : this.calcPoints(ctx);
     if (points < 1) {
       return null;
@@ -52883,7 +53157,7 @@ var Server = class {
       middleware.push(this.middleware.text);
     }
     this.setupRouteRateLimits(nsid2, config2);
-    this.routes[verb](`/xrpc/${nsid2}`, ...middleware, this.createHandler(nsid2, def2, config2.handler));
+    this.routes[verb](`/xrpc/${nsid2}`, ...middleware, this.createHandler(nsid2, def2, config2));
   }
   async catchall(req, _res, next) {
     const def2 = this.lex.getDef(req.params.methodId);
@@ -52897,8 +53171,11 @@ var Server = class {
     }
     return next();
   }
-  createHandler(nsid2, def2, handler) {
-    const validateReqInput = (req) => validateInput(nsid2, def2, req, this.options, this.lex);
+  createHandler(nsid2, def2, routeCfg) {
+    const routeOpts = {
+      blobLimit: routeCfg.opts?.blobLimit ?? this.options.payload?.blobLimit
+    };
+    const validateReqInput = (req) => validateInput(nsid2, def2, req, routeOpts, this.lex);
     const validateResOutput = this.options.validateResponse === false ? (output2) => output2 : (output2) => validateOutput(nsid2, def2, output2, this.lex);
     const assertValidXrpcParams2 = (params2) => this.lex.assertValidXrpcParams(nsid2, params2);
     const rlFns = this.routeRateLimiterFns[nsid2] ?? [];
@@ -52927,10 +53204,19 @@ var Server = class {
         if (result instanceof RateLimitExceededError) {
           return next(result);
         }
-        const outputUnvalidated = await handler(reqCtx);
+        const outputUnvalidated = await routeCfg.handler(reqCtx);
         if (isHandlerError(outputUnvalidated)) {
           throw XRPCError2.fromError(outputUnvalidated);
         }
+        if (outputUnvalidated && isHandlerPipeThrough(outputUnvalidated)) {
+          if (outputUnvalidated?.headers) {
+            Object.entries(outputUnvalidated.headers).forEach(([name2, val]) => {
+              res.header(name2, val);
+            });
+          }
+          res.header("Content-Type", outputUnvalidated.encoding).status(200).send(Buffer.from(outputUnvalidated.buffer));
+          return;
+        }
         if (!outputUnvalidated || isHandlerSuccess(outputUnvalidated)) {
           const output2 = validateResOutput(outputUnvalidated);
           if (output2?.headers) {
@@ -53072,6 +53358,24 @@ var Server = class {
 function isHandlerSuccess(v) {
   return handlerSuccess.safeParse(v).success;
 }
+function isHandlerPipeThrough(v) {
+  if (v === null || typeof v !== "object") {
+    return false;
+  }
+  if (!isString(v["encoding"]) || !(v["buffer"] instanceof ArrayBuffer)) {
+    return false;
+  }
+  if (v["headers"] !== void 0) {
+    if (v["headers"] === null || typeof v["headers"] !== "object") {
+      return false;
+    }
+    if (!Object.values(v["headers"]).every(isString)) {
+      return false;
+    }
+  }
+  return true;
+}
+var isString = (val) => typeof val === "string";
 var kRequestLocals = Symbol("requestLocals");
 function createLocalsMiddleware(nsid2) {
   return function(req, _res, next) {
@@ -53151,6 +53455,7 @@ var errorMiddleware = function(err, req, res, next) {
   handlerAuth,
   handlerError,
   handlerInput,
+  handlerPipeThrough,
   handlerSuccess,
   isHandlerError,
   isShared,