robojerk/codeql-action

Update checked-in dependencies

Browse source
This commit is contained in:
github-actions[bot] 2025-05-27 12:34:30 +00:00
parent 3934d2b758
commit 655a969b7c
221 changed files with 2272 additions and 1525 deletions
Download patch file Download diff file Expand all files Collapse all files

455
node_modules/@octokit/webhooks/dist-bundle/index.js generated vendored
View file

@ -1,4 +1,4 @@
// pkg/dist-src/createLogger.js
// pkg/dist-src/create-logger.js
var createLogger = (logger) => ({
debug: () => {
},
@ -510,289 +510,262 @@ async function verifyAndReceive(state, event) {
});
}
// pkg/dist-src/middleware/node/get-missing-headers.js
// pkg/dist-src/middleware/create-middleware.js
var isApplicationJsonRE = /^\s*(application\/json)\s*(?:;|$)/u;
var WEBHOOK_HEADERS = [
"x-github-event",
"x-hub-signature-256",
"x-github-delivery"
];
function getMissingHeaders(request) {
return WEBHOOK_HEADERS.filter((header) => !(header in request.headers));
function createMiddleware(options) {
const { handleResponse: handleResponse3, getRequestHeader: getRequestHeader3, getPayload: getPayload3 } = options;
return function middleware(webhooks, options2) {
return async function octokitWebhooksMiddleware(request, response, next) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
return handleResponse3(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
}),
422,
{
"content-type": "application/json"
},
response
);
}
if (pathname !== options2.path) {
next?.();
return handleResponse3(null);
} else if (request.method !== "POST") {
return handleResponse3(
JSON.stringify({
error: `Unknown route: ${request.method} ${pathname}`
}),
404,
{
"content-type": "application/json"
},
response
);
}
const contentType = getRequestHeader3(request, "content-type");
if (typeof contentType !== "string" || !isApplicationJsonRE.test(contentType)) {
return handleResponse3(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
}),
415,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
const missingHeaders = WEBHOOK_HEADERS.filter((header) => {
return getRequestHeader3(request, header) == void 0;
}).join(", ");
if (missingHeaders) {
return handleResponse3(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
}),
400,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
const eventName = getRequestHeader3(
request,
"x-github-event"
);
const signature = getRequestHeader3(request, "x-hub-signature-256");
const id = getRequestHeader3(request, "x-github-delivery");
options2.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
let timeout;
const timeoutPromise = new Promise((resolve) => {
timeout = setTimeout(() => {
didTimeout = true;
resolve(
handleResponse3(
"still processing\n",
202,
{
"Content-Type": "text/plain",
accept: "application/json"
},
response
)
);
}, options2.timeout);
});
const processWebhook = async () => {
try {
const payload = await getPayload3(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature
});
clearTimeout(timeout);
if (didTimeout) return handleResponse3(null);
return handleResponse3(
"ok\n",
200,
{
"content-type": "text/plain",
accept: "application/json"
},
response
);
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return handleResponse3(null);
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
const statusCode = typeof err.status !== "undefined" ? err.status : 500;
options2.log.error(error);
return handleResponse3(
JSON.stringify({
error: errorMessage
}),
statusCode,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
};
return await Promise.race([timeoutPromise, processWebhook()]);
};
};
}
// pkg/dist-src/middleware/node/handle-response.js
function handleResponse(body, status = 200, headers = {}, response) {
if (body === null) {
return false;
}
headers["content-length"] = body.length.toString();
response.writeHead(status, headers).end(body);
return true;
}
// pkg/dist-src/middleware/node/get-request-header.js
function getRequestHeader(request, key) {
return request.headers[key];
}
// pkg/dist-src/concat-uint8array.js
function concatUint8Array(data) {
if (data.length === 0) {
return new Uint8Array(0);
}
let totalLength = 0;
for (let i = 0; i < data.length; i++) {
totalLength += data[i].length;
}
if (totalLength === 0) {
return new Uint8Array(0);
}
const result = new Uint8Array(totalLength);
let offset = 0;
for (let i = 0; i < data.length; i++) {
result.set(data[i], offset);
offset += data[i].length;
}
return result;
}
// pkg/dist-src/middleware/node/get-payload.js
function getPayload(request) {
if (typeof request.body === "object" && "rawBody" in request && request.rawBody instanceof Buffer) {
return Promise.resolve(request.rawBody.toString("utf8"));
var textDecoder = new TextDecoder("utf-8", { fatal: false });
var decode = textDecoder.decode.bind(textDecoder);
async function getPayload(request) {
if (typeof request.body === "object" && "rawBody" in request && request.rawBody instanceof Uint8Array) {
return decode(request.rawBody);
} else if (typeof request.body === "string") {
return Promise.resolve(request.body);
return request.body;
}
const payload = await getPayloadFromRequestStream(request);
return decode(payload);
}
function getPayloadFromRequestStream(request) {
return new Promise((resolve, reject) => {
let data = [];
request.on(
"error",
(error) => reject(new AggregateError([error], error.message))
);
request.on("data", (chunk) => data.push(chunk));
request.on(
"end",
() => (
// setImmediate improves the throughput by reducing the pressure from
// the event loop
setImmediate(
resolve,
data.length === 1 ? data[0].toString("utf8") : Buffer.concat(data).toString("utf8")
)
)
);
request.on("data", data.push.bind(data));
request.on("end", () => {
const result = concatUint8Array(data);
queueMicrotask(() => resolve(result));
});
});
}
// pkg/dist-src/middleware/node/on-unhandled-request-default.js
function onUnhandledRequestDefault(request, response) {
response.writeHead(404, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Unknown route: ${request.method} ${request.url}`
})
);
}
// pkg/dist-src/middleware/node/middleware.js
async function middleware(webhooks, options, request, response, next) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
response.writeHead(422, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
})
);
return true;
}
if (pathname !== options.path) {
next?.();
return false;
} else if (request.method !== "POST") {
onUnhandledRequestDefault(request, response);
return true;
}
if (!request.headers["content-type"] || !request.headers["content-type"].startsWith("application/json")) {
response.writeHead(415, {
"content-type": "application/json",
accept: "application/json"
});
response.end(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
})
);
return true;
}
const missingHeaders = getMissingHeaders(request).join(", ");
if (missingHeaders) {
response.writeHead(400, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
})
);
return true;
}
const eventName = request.headers["x-github-event"];
const signatureSHA256 = request.headers["x-hub-signature-256"];
const id = request.headers["x-github-delivery"];
options.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
const timeout = setTimeout(() => {
didTimeout = true;
response.statusCode = 202;
response.end("still processing\n");
}, 9e3).unref();
try {
const payload = await getPayload(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature: signatureSHA256
});
clearTimeout(timeout);
if (didTimeout) return true;
response.end("ok\n");
return true;
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return true;
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
response.statusCode = typeof err.status !== "undefined" ? err.status : 500;
options.log.error(error);
response.end(
JSON.stringify({
error: errorMessage
})
);
return true;
}
}
// pkg/dist-src/middleware/node/index.js
function createNodeMiddleware(webhooks, {
path = "/api/github/webhooks",
log = createLogger()
log = createLogger(),
timeout = 9e3
} = {}) {
return middleware.bind(null, webhooks, {
return createMiddleware({
handleResponse,
getRequestHeader,
getPayload
})(webhooks, {
path,
log
log,
timeout
});
}
// pkg/dist-src/middleware/web/get-missing-headers.js
var WEBHOOK_HEADERS2 = [
"x-github-event",
"x-hub-signature-256",
"x-github-delivery"
];
function getMissingHeaders2(request) {
return WEBHOOK_HEADERS2.filter((header) => !request.headers.has(header));
}
// pkg/dist-src/middleware/web/get-payload.js
function getPayload2(request) {
return request.text();
}
// pkg/dist-src/middleware/web/on-unhandled-request-default.js
function onUnhandledRequestDefault2(request) {
return new Response(
JSON.stringify({
error: `Unknown route: ${request.method} ${request.url}`
}),
{
status: 404,
headers: {
"content-type": "application/json"
}
}
);
// pkg/dist-src/middleware/web/get-request-header.js
function getRequestHeader2(request, key) {
return request.headers.get(key);
}
// pkg/dist-src/middleware/web/middleware.js
async function middleware2(webhooks, options, request) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
return new Response(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
}),
{
status: 422,
headers: {
"content-type": "application/json"
}
}
);
// pkg/dist-src/middleware/web/handle-response.js
function handleResponse2(body, status = 200, headers = {}) {
if (body !== null) {
headers["content-length"] = body.length.toString();
}
if (pathname !== options.path || request.method !== "POST") {
return onUnhandledRequestDefault2(request);
}
if (typeof request.headers.get("content-type") !== "string" || !request.headers.get("content-type").startsWith("application/json")) {
return new Response(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
}),
{
status: 415,
headers: {
"content-type": "application/json"
}
}
);
}
const missingHeaders = getMissingHeaders2(request).join(", ");
if (missingHeaders) {
return new Response(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
}),
{
status: 422,
headers: {
"content-type": "application/json"
}
}
);
}
const eventName = request.headers.get("x-github-event");
const signatureSHA256 = request.headers.get("x-hub-signature-256");
const id = request.headers.get("x-github-delivery");
options.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
let timeout;
const timeoutPromise = new Promise((resolve) => {
timeout = setTimeout(() => {
didTimeout = true;
resolve(
new Response("still processing\n", {
status: 202,
headers: { "Content-Type": "text/plain" }
})
);
}, 9e3).unref();
return new Response(body, {
status,
headers
});
const processWebhook = async () => {
try {
const payload = await getPayload2(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature: signatureSHA256
});
clearTimeout(timeout);
if (didTimeout) return new Response(null);
return new Response("ok\n");
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return new Response(null);
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
options.log.error(error);
return new Response(
JSON.stringify({
error: errorMessage
}),
{
status: typeof err.status !== "undefined" ? err.status : 500,
headers: {
"content-type": "application/json"
}
}
);
}
};
return await Promise.race([timeoutPromise, processWebhook()]);
}
// pkg/dist-src/middleware/web/index.js
function createWebMiddleware(webhooks, {
path = "/api/github/webhooks",
log = createLogger()
log = createLogger(),
timeout = 9e3
} = {}) {
return middleware2.bind(null, webhooks, {
return createMiddleware({
handleResponse: handleResponse2,
getRequestHeader: getRequestHeader2,
getPayload: getPayload2
})(webhooks, {
path,
log
log,
timeout
});
}

8
node_modules/@octokit/webhooks/dist-bundle/index.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

22
node_modules/@octokit/webhooks/dist-src/concat-uint8array.js generated vendored Normal file
View file

@ -0,0 +1,22 @@
function concatUint8Array(data) {
if (data.length === 0) {
return new Uint8Array(0);
}
let totalLength = 0;
for (let i = 0; i < data.length; i++) {
totalLength += data[i].length;
}
if (totalLength === 0) {
return new Uint8Array(0);
}
const result = new Uint8Array(totalLength);
let offset = 0;
for (let i = 0; i < data.length; i++) {
result.set(data[i], offset);
offset += data[i].length;
}
return result;
}
export {
concatUint8Array
};

0
node_modules/@octokit/webhooks/dist-src/createLogger.js → node_modules/@octokit/webhooks/dist-src/create-logger.js generated vendored
View file

2
node_modules/@octokit/webhooks/dist-src/event-handler/index.js generated vendored
View file

@ -1,4 +1,4 @@
import { createLogger } from "../createLogger.js";
import { createLogger } from "../create-logger.js";
import {
receiverOn as on,
receiverOnAny as onAny,

2
node_modules/@octokit/webhooks/dist-src/index.js generated vendored
View file

@ -1,4 +1,4 @@
import { createLogger } from "./createLogger.js";
import { createLogger } from "./create-logger.js";
import {
createEventHandler
} from "./event-handler/index.js";

142
node_modules/@octokit/webhooks/dist-src/middleware/create-middleware.js generated vendored Normal file
View file

@ -0,0 +1,142 @@
const isApplicationJsonRE = /^\s*(application\/json)\s*(?:;|$)/u;
const WEBHOOK_HEADERS = [
"x-github-event",
"x-hub-signature-256",
"x-github-delivery"
];
function createMiddleware(options) {
const { handleResponse, getRequestHeader, getPayload } = options;
return function middleware(webhooks, options2) {
return async function octokitWebhooksMiddleware(request, response, next) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
return handleResponse(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
}),
422,
{
"content-type": "application/json"
},
response
);
}
if (pathname !== options2.path) {
next?.();
return handleResponse(null);
} else if (request.method !== "POST") {
return handleResponse(
JSON.stringify({
error: `Unknown route: ${request.method} ${pathname}`
}),
404,
{
"content-type": "application/json"
},
response
);
}
const contentType = getRequestHeader(request, "content-type");
if (typeof contentType !== "string" || !isApplicationJsonRE.test(contentType)) {
return handleResponse(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
}),
415,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
const missingHeaders = WEBHOOK_HEADERS.filter((header) => {
return getRequestHeader(request, header) == void 0;
}).join(", ");
if (missingHeaders) {
return handleResponse(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
}),
400,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
const eventName = getRequestHeader(
request,
"x-github-event"
);
const signature = getRequestHeader(request, "x-hub-signature-256");
const id = getRequestHeader(request, "x-github-delivery");
options2.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
let timeout;
const timeoutPromise = new Promise((resolve) => {
timeout = setTimeout(() => {
didTimeout = true;
resolve(
handleResponse(
"still processing\n",
202,
{
"Content-Type": "text/plain",
accept: "application/json"
},
response
)
);
}, options2.timeout);
});
const processWebhook = async () => {
try {
const payload = await getPayload(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature
});
clearTimeout(timeout);
if (didTimeout) return handleResponse(null);
return handleResponse(
"ok\n",
200,
{
"content-type": "text/plain",
accept: "application/json"
},
response
);
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return handleResponse(null);
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
const statusCode = typeof err.status !== "undefined" ? err.status : 500;
options2.log.error(error);
return handleResponse(
JSON.stringify({
error: errorMessage
}),
statusCode,
{
"content-type": "application/json",
accept: "application/json"
},
response
);
}
};
return await Promise.race([timeoutPromise, processWebhook()]);
};
};
}
export {
createMiddleware
};

11
node_modules/@octokit/webhooks/dist-src/middleware/node/get-missing-headers.js generated vendored
View file

@ -1,11 +0,0 @@
const WEBHOOK_HEADERS = [
"x-github-event",
"x-hub-signature-256",
"x-github-delivery"
];
function getMissingHeaders(request) {
return WEBHOOK_HEADERS.filter((header) => !(header in request.headers));
}
export {
getMissingHeaders
};

35
node_modules/@octokit/webhooks/dist-src/middleware/node/get-payload.js generated vendored
View file

@ -1,29 +1,30 @@
function getPayload(request) {
if (typeof request.body === "object" && "rawBody" in request && request.rawBody instanceof Buffer) {
return Promise.resolve(request.rawBody.toString("utf8"));
import { concatUint8Array } from "../../concat-uint8array.js";
const textDecoder = new TextDecoder("utf-8", { fatal: false });
const decode = textDecoder.decode.bind(textDecoder);
async function getPayload(request) {
if (typeof request.body === "object" && "rawBody" in request && request.rawBody instanceof Uint8Array) {
return decode(request.rawBody);
} else if (typeof request.body === "string") {
return Promise.resolve(request.body);
return request.body;
}
const payload = await getPayloadFromRequestStream(request);
return decode(payload);
}
function getPayloadFromRequestStream(request) {
return new Promise((resolve, reject) => {
let data = [];
request.on(
"error",
(error) => reject(new AggregateError([error], error.message))
);
request.on("data", (chunk) => data.push(chunk));
request.on(
"end",
() => (
// setImmediate improves the throughput by reducing the pressure from
// the event loop
setImmediate(
resolve,
data.length === 1 ? data[0].toString("utf8") : Buffer.concat(data).toString("utf8")
)
)
);
request.on("data", data.push.bind(data));
request.on("end", () => {
const result = concatUint8Array(data);
queueMicrotask(() => resolve(result));
});
});
}
export {
getPayload
getPayload,
getPayloadFromRequestStream
};

6
node_modules/@octokit/webhooks/dist-src/middleware/node/get-request-header.js generated vendored Normal file
View file

@ -0,0 +1,6 @@
function getRequestHeader(request, key) {
return request.headers[key];
}
export {
getRequestHeader
};

11
node_modules/@octokit/webhooks/dist-src/middleware/node/handle-response.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
function handleResponse(body, status = 200, headers = {}, response) {
if (body === null) {
return false;
}
headers["content-length"] = body.length.toString();
response.writeHead(status, headers).end(body);
return true;
}
export {
handleResponse
};

19
node_modules/@octokit/webhooks/dist-src/middleware/node/index.js generated vendored
View file

@ -1,12 +1,21 @@
import { createLogger } from "../../createLogger.js";
import { middleware } from "./middleware.js";
import { createLogger } from "../../create-logger.js";
import { createMiddleware } from "../create-middleware.js";
import { handleResponse } from "./handle-response.js";
import { getRequestHeader } from "./get-request-header.js";
import { getPayload } from "./get-payload.js";
function createNodeMiddleware(webhooks, {
path = "/api/github/webhooks",
log = createLogger()
log = createLogger(),
timeout = 9e3
} = {}) {
return middleware.bind(null, webhooks, {
return createMiddleware({
handleResponse,
getRequestHeader,
getPayload
})(webhooks, {
path,
log
log,
timeout
});
}
export {

89
node_modules/@octokit/webhooks/dist-src/middleware/node/middleware.js generated vendored
View file

@ -1,89 +0,0 @@
import { getMissingHeaders } from "./get-missing-headers.js";
import { getPayload } from "./get-payload.js";
import { onUnhandledRequestDefault } from "./on-unhandled-request-default.js";
async function middleware(webhooks, options, request, response, next) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
response.writeHead(422, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
})
);
return true;
}
if (pathname !== options.path) {
next?.();
return false;
} else if (request.method !== "POST") {
onUnhandledRequestDefault(request, response);
return true;
}
if (!request.headers["content-type"] || !request.headers["content-type"].startsWith("application/json")) {
response.writeHead(415, {
"content-type": "application/json",
accept: "application/json"
});
response.end(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
})
);
return true;
}
const missingHeaders = getMissingHeaders(request).join(", ");
if (missingHeaders) {
response.writeHead(400, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
})
);
return true;
}
const eventName = request.headers["x-github-event"];
const signatureSHA256 = request.headers["x-hub-signature-256"];
const id = request.headers["x-github-delivery"];
options.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
const timeout = setTimeout(() => {
didTimeout = true;
response.statusCode = 202;
response.end("still processing\n");
}, 9e3).unref();
try {
const payload = await getPayload(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature: signatureSHA256
});
clearTimeout(timeout);
if (didTimeout) return true;
response.end("ok\n");
return true;
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return true;
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
response.statusCode = typeof err.status !== "undefined" ? err.status : 500;
options.log.error(error);
response.end(
JSON.stringify({
error: errorMessage
})
);
return true;
}
}
export {
middleware
};

13
node_modules/@octokit/webhooks/dist-src/middleware/node/on-unhandled-request-default.js generated vendored
View file

@ -1,13 +0,0 @@
function onUnhandledRequestDefault(request, response) {
response.writeHead(404, {
"content-type": "application/json"
});
response.end(
JSON.stringify({
error: `Unknown route: ${request.method} ${request.url}`
})
);
}
export {
onUnhandledRequestDefault
};

11
node_modules/@octokit/webhooks/dist-src/middleware/web/get-missing-headers.js generated vendored
View file

@ -1,11 +0,0 @@
const WEBHOOK_HEADERS = [
"x-github-event",
"x-hub-signature-256",
"x-github-delivery"
];
function getMissingHeaders(request) {
return WEBHOOK_HEADERS.filter((header) => !request.headers.has(header));
}
export {
getMissingHeaders
};

6
node_modules/@octokit/webhooks/dist-src/middleware/web/get-request-header.js generated vendored Normal file
View file

@ -0,0 +1,6 @@
function getRequestHeader(request, key) {
return request.headers.get(key);
}
export {
getRequestHeader
};

12
node_modules/@octokit/webhooks/dist-src/middleware/web/handle-response.js generated vendored Normal file
View file

@ -0,0 +1,12 @@
function handleResponse(body, status = 200, headers = {}) {
if (body !== null) {
headers["content-length"] = body.length.toString();
}
return new Response(body, {
status,
headers
});
}
export {
handleResponse
};

19
node_modules/@octokit/webhooks/dist-src/middleware/web/index.js generated vendored
View file

@ -1,12 +1,21 @@
import { createLogger } from "../../createLogger.js";
import { middleware } from "./middleware.js";
import { createLogger } from "../../create-logger.js";
import { createMiddleware } from "../create-middleware.js";
import { getPayload } from "./get-payload.js";
import { getRequestHeader } from "./get-request-header.js";
import { handleResponse } from "./handle-response.js";
function createWebMiddleware(webhooks, {
path = "/api/github/webhooks",
log = createLogger()
log = createLogger(),
timeout = 9e3
} = {}) {
return middleware.bind(null, webhooks, {
return createMiddleware({
handleResponse,
getRequestHeader,
getPayload
})(webhooks, {
path,
log
log,
timeout
});
}
export {

103
node_modules/@octokit/webhooks/dist-src/middleware/web/middleware.js generated vendored
View file

@ -1,103 +0,0 @@
import { getMissingHeaders } from "./get-missing-headers.js";
import { getPayload } from "./get-payload.js";
import { onUnhandledRequestDefault } from "./on-unhandled-request-default.js";
async function middleware(webhooks, options, request) {
let pathname;
try {
pathname = new URL(request.url, "http://localhost").pathname;
} catch (error) {
return new Response(
JSON.stringify({
error: `Request URL could not be parsed: ${request.url}`
}),
{
status: 422,
headers: {
"content-type": "application/json"
}
}
);
}
if (pathname !== options.path || request.method !== "POST") {
return onUnhandledRequestDefault(request);
}
if (typeof request.headers.get("content-type") !== "string" || !request.headers.get("content-type").startsWith("application/json")) {
return new Response(
JSON.stringify({
error: `Unsupported "Content-Type" header value. Must be "application/json"`
}),
{
status: 415,
headers: {
"content-type": "application/json"
}
}
);
}
const missingHeaders = getMissingHeaders(request).join(", ");
if (missingHeaders) {
return new Response(
JSON.stringify({
error: `Required headers missing: ${missingHeaders}`
}),
{
status: 422,
headers: {
"content-type": "application/json"
}
}
);
}
const eventName = request.headers.get("x-github-event");
const signatureSHA256 = request.headers.get("x-hub-signature-256");
const id = request.headers.get("x-github-delivery");
options.log.debug(`${eventName} event received (id: ${id})`);
let didTimeout = false;
let timeout;
const timeoutPromise = new Promise((resolve) => {
timeout = setTimeout(() => {
didTimeout = true;
resolve(
new Response("still processing\n", {
status: 202,
headers: { "Content-Type": "text/plain" }
})
);
}, 9e3).unref();
});
const processWebhook = async () => {
try {
const payload = await getPayload(request);
await webhooks.verifyAndReceive({
id,
name: eventName,
payload,
signature: signatureSHA256
});
clearTimeout(timeout);
if (didTimeout) return new Response(null);
return new Response("ok\n");
} catch (error) {
clearTimeout(timeout);
if (didTimeout) return new Response(null);
const err = Array.from(error.errors)[0];
const errorMessage = err.message ? `${err.name}: ${err.message}` : "Error: An Unspecified error occurred";
options.log.error(error);
return new Response(
JSON.stringify({
error: errorMessage
}),
{
status: typeof err.status !== "undefined" ? err.status : 500,
headers: {
"content-type": "application/json"
}
}
);
}
};
return await Promise.race([timeoutPromise, processWebhook()]);
}
export {
middleware
};

16
node_modules/@octokit/webhooks/dist-src/middleware/web/on-unhandled-request-default.js generated vendored
View file

@ -1,16 +0,0 @@
function onUnhandledRequestDefault(request) {
return new Response(
JSON.stringify({
error: `Unknown route: ${request.method} ${request.url}`
}),
{
status: 404,
headers: {
"content-type": "application/json"
}
}
);
}
export {
onUnhandledRequestDefault
};

1
node_modules/@octokit/webhooks/dist-types/concat-uint8array.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare function concatUint8Array(data: Uint8Array[]): Uint8Array;

0
node_modules/@octokit/webhooks/dist-types/createLogger.d.ts → node_modules/@octokit/webhooks/dist-types/create-logger.d.ts generated vendored
View file

2
node_modules/@octokit/webhooks/dist-types/event-handler/index.d.ts generated vendored
View file

@ -1,4 +1,4 @@
import type { EmitterWebhookEvent, EmitterWebhookEventName, HandlerFunction, Options, WebhookError, WebhookEventHandlerError } from "../types.js";
import type { EmitterWebhookEvent, EmitterWebhookEventName, HandlerFunction, Options, WebhookError, WebhookEventHandlerError } from "../types.ts";
export interface EventHandler<TTransformed = unknown> {
on<E extends EmitterWebhookEventName>(event: E | E[], callback: HandlerFunction<E, TTransformed>): void;
onAny(handler: (event: TTransformed extends unknown ? EmitterWebhookEvent : EmitterWebhookEvent & TTransformed) => any): void;

2
node_modules/@octokit/webhooks/dist-types/event-handler/on.d.ts generated vendored
View file

@ -1,4 +1,4 @@
import type { EmitterWebhookEvent, EmitterWebhookEventName, State, WebhookEventHandlerError } from "../types.js";
import type { EmitterWebhookEvent, EmitterWebhookEventName, State, WebhookEventHandlerError } from "../types.ts";
export declare function receiverOn(state: State, webhookNameOrNames: EmitterWebhookEventName | EmitterWebhookEventName[], handler: Function): void;
export declare function receiverOnAny<TTransformed>(state: State, handler: (event: TTransformed extends unknown ? EmitterWebhookEvent : EmitterWebhookEvent & TTransformed) => any): void;
export declare function receiverOnError<TTransformed>(state: State, handler: (event: WebhookEventHandlerError<TTransformed>) => any): void;

2
node_modules/@octokit/webhooks/dist-types/event-handler/receive.d.ts generated vendored
View file

@ -1,2 +1,2 @@
import type { EmitterWebhookEvent, State, WebhookError } from "../types.js";
import type { EmitterWebhookEvent, State, WebhookError } from "../types.ts";
export declare function receiverHandle(state: State, event: EmitterWebhookEvent | WebhookError): Promise<void>;

2
node_modules/@octokit/webhooks/dist-types/event-handler/remove-listener.d.ts generated vendored
View file

@ -1,2 +1,2 @@
import type { EmitterWebhookEventName, State } from "../types.js";
import type { EmitterWebhookEventName, State } from "../types.ts";
export declare function removeListener(state: State, webhookNameOrNames: "*" | EmitterWebhookEventName | EmitterWebhookEventName[], handler: Function): void;

2
node_modules/@octokit/webhooks/dist-types/generated/webhook-identifiers.d.ts generated vendored
View file

@ -1,4 +1,4 @@
import type { WebhookEventDefinition } from "../types.js";
import type { WebhookEventDefinition } from "../types.ts";
export type EventPayloadMap = {
branch_protection_configuration: WebhookEventDefinition<"branch-protection-configuration-disabled"> | WebhookEventDefinition<"branch-protection-configuration-enabled">;
branch_protection_rule: WebhookEventDefinition<"branch-protection-rule-created"> | WebhookEventDefinition<"branch-protection-rule-deleted"> | WebhookEventDefinition<"branch-protection-rule-edited">;

10
node_modules/@octokit/webhooks/dist-types/index.d.ts generated vendored
View file

@ -1,8 +1,8 @@
import { createEventHandler } from "./event-handler/index.js";
import type { EmitterWebhookEvent, EmitterWebhookEventName, HandlerFunction, RemoveHandlerFunction, Options, WebhookError, WebhookEventHandlerError, EmitterWebhookEventWithStringPayloadAndSignature } from "./types.js";
export { createNodeMiddleware } from "./middleware/node/index.js";
export { createWebMiddleware } from "./middleware/web/index.js";
export { emitterEventNames } from "./generated/webhook-names.js";
import { createEventHandler } from "./event-handler/index.ts";
import type { EmitterWebhookEvent, EmitterWebhookEventName, HandlerFunction, RemoveHandlerFunction, Options, WebhookError, WebhookEventHandlerError, EmitterWebhookEventWithStringPayloadAndSignature } from "./types.ts";
export { createNodeMiddleware } from "./middleware/node/index.ts";
export { createWebMiddleware } from "./middleware/web/index.ts";
export { emitterEventNames } from "./generated/webhook-names.ts";
declare class Webhooks<TTransformed = unknown> {
sign: (payload: string) => Promise<string>;
verify: (eventPayload: string, signature: string) => Promise<boolean>;

11
node_modules/@octokit/webhooks/dist-types/middleware/create-middleware.d.ts generated vendored Normal file
View file

@ -0,0 +1,11 @@
import type { Webhooks } from "../index.ts";
import type { MiddlewareOptions } from "./types.ts";
type CreateMiddlewareOptions = {
handleResponse: (body: string | null, status?: number, headers?: Record<string, string>, response?: any) => any;
getPayload: (request: Request) => Promise<string>;
getRequestHeader: <T = string>(request: Request, key: string) => T;
};
type IncomingMessage = any;
type ServerResponse = any;
export declare function createMiddleware(options: CreateMiddlewareOptions): (webhooks: Webhooks, options: Required<MiddlewareOptions>) => (request: IncomingMessage, response?: ServerResponse, next?: Function) => Promise<any>;
export {};

3
node_modules/@octokit/webhooks/dist-types/middleware/node/get-missing-headers.d.ts generated vendored
View file

@ -1,3 +0,0 @@
type IncomingMessage = any;
export declare function getMissingHeaders(request: IncomingMessage): string[];
export {};

1
node_modules/@octokit/webhooks/dist-types/middleware/node/get-payload.d.ts generated vendored
View file

@ -1,3 +1,4 @@
type IncomingMessage = any;
export declare function getPayload(request: IncomingMessage): Promise<string>;
export declare function getPayloadFromRequestStream(request: IncomingMessage): Promise<Uint8Array>;
export {};

1
node_modules/@octokit/webhooks/dist-types/middleware/node/get-request-header.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare function getRequestHeader<T = string>(request: any, key: string): T;

1
node_modules/@octokit/webhooks/dist-types/middleware/node/handle-response.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare function handleResponse(body: string | null, status?: number, headers?: Record<string, string>, response?: any): boolean;

6
node_modules/@octokit/webhooks/dist-types/middleware/node/index.d.ts generated vendored
View file

@ -1,3 +1,3 @@
import type { Webhooks } from "../../index.js";
import type { MiddlewareOptions } from "../types.js";
export declare function createNodeMiddleware(webhooks: Webhooks, { path, log, }?: MiddlewareOptions): (request: import("http").IncomingMessage, response: import("http").ServerResponse<import("http").IncomingMessage>, next?: Function | undefined) => Promise<boolean>;
import type { Webhooks } from "../../index.ts";
import type { MiddlewareOptions } from "../types.ts";
export declare function createNodeMiddleware(webhooks: Webhooks, { path, log, timeout, }?: MiddlewareOptions): (request: any, response?: any, next?: Function) => Promise<any>;

4
node_modules/@octokit/webhooks/dist-types/middleware/node/middleware.d.ts generated vendored
View file

@ -1,4 +0,0 @@
import type { IncomingMessage, ServerResponse } from "node:http";
import type { Webhooks } from "../../index.js";
import type { MiddlewareOptions } from "../types.js";
export declare function middleware(webhooks: Webhooks, options: Required<MiddlewareOptions>, request: IncomingMessage, response: ServerResponse, next?: Function): Promise<boolean>;

4
node_modules/@octokit/webhooks/dist-types/middleware/node/on-unhandled-request-default.d.ts generated vendored
View file

@ -1,4 +0,0 @@
type IncomingMessage = any;
type ServerResponse = any;
export declare function onUnhandledRequestDefault(request: IncomingMessage, response: ServerResponse): void;
export {};

3
node_modules/@octokit/webhooks/dist-types/middleware/types.d.ts generated vendored
View file

@ -1,5 +1,6 @@
import type { Logger } from "../createLogger.js";
import type { Logger } from "../create-logger.ts";
export type MiddlewareOptions = {
timeout?: number;
path?: string;
log?: Logger;
};

1
node_modules/@octokit/webhooks/dist-types/middleware/web/get-missing-headers.d.ts generated vendored
View file

@ -1 +0,0 @@
export declare function getMissingHeaders(request: Request): string[];

1
node_modules/@octokit/webhooks/dist-types/middleware/web/get-request-header.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare function getRequestHeader<T = string>(request: Request, key: string): T;

1
node_modules/@octokit/webhooks/dist-types/middleware/web/handle-response.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export declare function handleResponse(body: string | null, status?: number, headers?: Record<string, string>): import("undici-types").Response;

6
node_modules/@octokit/webhooks/dist-types/middleware/web/index.d.ts generated vendored
View file

@ -1,3 +1,3 @@
import type { Webhooks } from "../../index.js";
import type { MiddlewareOptions } from "../types.js";
export declare function createWebMiddleware(webhooks: Webhooks, { path, log, }?: MiddlewareOptions): (request: Request) => Promise<Response>;
import type { Webhooks } from "../../index.ts";
import type { MiddlewareOptions } from "../types.ts";
export declare function createWebMiddleware(webhooks: Webhooks, { path, log, timeout, }?: MiddlewareOptions): (request: any, response?: any, next?: Function) => Promise<any>;

3
node_modules/@octokit/webhooks/dist-types/middleware/web/middleware.d.ts generated vendored
View file

@ -1,3 +0,0 @@
import type { Webhooks } from "../../index.js";
import type { MiddlewareOptions } from "../types.js";
export declare function middleware(webhooks: Webhooks, options: Required<MiddlewareOptions>, request: Request): Promise<Response>;

1
node_modules/@octokit/webhooks/dist-types/middleware/web/on-unhandled-request-default.d.ts generated vendored
View file

@ -1 +0,0 @@
export declare function onUnhandledRequestDefault(request: Request): import("undici-types").Response;

8
node_modules/@octokit/webhooks/dist-types/types.d.ts generated vendored
View file

@ -1,9 +1,9 @@
import type { RequestError } from "@octokit/request-error";
import type { webhooks as OpenAPIWebhooks } from "@octokit/openapi-webhooks-types";
import type { EventPayloadMap } from "./generated/webhook-identifiers.js";
import type { Logger } from "./createLogger.js";
import type { EventHandler } from "./event-handler/index.js";
import type { emitterEventNames } from "./generated/webhook-names.js";
import type { EventPayloadMap } from "./generated/webhook-identifiers.ts";
import type { Logger } from "./create-logger.ts";
import type { EventHandler } from "./event-handler/index.ts";
import type { emitterEventNames } from "./generated/webhook-names.ts";
export type WebhookEventName = keyof EventPayloadMap;
export type ExtractEvents<TEventName> = TEventName extends `${infer _TWebhookEvent}.${infer _TAction}` ? never : TEventName;
export type WebhookEvents = ExtractEvents<EmitterWebhookEventName>;

4
node_modules/@octokit/webhooks/dist-types/verify-and-receive.d.ts generated vendored
View file

@ -1,5 +1,5 @@
import type { EmitterWebhookEventWithStringPayloadAndSignature, State } from "./types.js";
import type { EventHandler } from "./event-handler/index.js";
import type { EmitterWebhookEventWithStringPayloadAndSignature, State } from "./types.ts";
import type { EventHandler } from "./event-handler/index.ts";
export declare function verifyAndReceive(state: State & {
secret: string;
eventHandler: EventHandler<unknown>;

17
node_modules/@octokit/webhooks/package.json generated vendored
View file

@ -1,6 +1,6 @@
{
"name": "@octokit/webhooks",
"version": "13.8.0",
"version": "14.0.0",
"description": "GitHub webhook events toolset for Node.js",
"keywords": [],
"repository": "github:octokit/webhooks.js",
@ -8,18 +8,19 @@
"author": "Gregor Martynus (https://twitter.com/gr2m)",
"type": "module",
"dependencies": {
"@octokit/openapi-webhooks-types": "10.4.0",
"@octokit/request-error": "^6.1.7",
"@octokit/webhooks-methods": "^5.1.1"
"@octokit/openapi-webhooks-types": "11.0.0",
"@octokit/request-error": "^7.0.0",
"@octokit/webhooks-methods": "^6.0.0"
},
"devDependencies": {
"@octokit/openapi-webhooks": "10.4.0",
"@octokit/openapi-webhooks": "11.0.0",
"@octokit/tsconfig": "^4.0.0",
"@types/express": "^5.0.1",
"@types/node": "^22.0.0",
"@vitest/coverage-v8": "^3.0.0",
"esbuild": "^0.25.0",
"express": "^4.17.1",
"glob": "^11.0.0",
"express": "^5.1.0",
"get-port": "^7.1.0",
"prettier": "3.5.3",
"prettier-plugin-packagejson": "^2.2.9",
"tsx": "^4.19.3",
@ -27,7 +28,7 @@
"vitest": "^3.0.0"
},
"engines": {
"node": ">= 18"
"node": ">= 20"
},
"publishConfig": {
"access": "public",