franpcode/create-better-t-stack
1
0
Fork 0
mirror of https://github.com/FranP-code/create-better-t-stack.git synced 2025-10-12 23:52:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

cli: update deps

Browse Source
This commit is contained in:
Aman Varshney
2025-07-12 21:47:34 +05:30
parent fcc1da8742
commit bd136792df
235 changed files with 22411 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

524
apps/web/.open-next/.build/cache.cjs Normal file
View File

@@ -0,0 +1,524 @@
globalThis.disableIncrementalCache = false;globalThis.disableDynamoDBCache = false;globalThis.isNextAfter15 = true;globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.0";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ../../node_modules/@opennextjs/aws/dist/adapters/cache.js
var cache_exports = {};
__export(cache_exports, {
default: () => Cache
});
module.exports = __toCommonJS(cache_exports);
// ../../node_modules/@opennextjs/aws/dist/utils/error.js
function isOpenNextError(e) {
try {
return "__openNextInternal" in e;
} catch {
return false;
}
}
// ../../node_modules/@opennextjs/aws/dist/adapters/logger.js
function debug(...args) {
if (globalThis.openNextDebug) {
console.log(...args);
}
}
function warn(...args) {
console.warn(...args);
}
var DOWNPLAYED_ERROR_LOGS = [
{
clientName: "S3Client",
commandName: "GetObjectCommand",
errorName: "NoSuchKey"
}
];
var isDownplayedErrorLog = (errorLog) => DOWNPLAYED_ERROR_LOGS.some((downplayedInput) => downplayedInput.clientName === errorLog?.clientName && downplayedInput.commandName === errorLog?.commandName && (downplayedInput.errorName === errorLog?.error?.name || downplayedInput.errorName === errorLog?.error?.Code));
function error(...args) {
if (args.some((arg) => isDownplayedErrorLog(arg))) {
return debug(...args);
}
if (args.some((arg) => isOpenNextError(arg))) {
const error2 = args.find((arg) => isOpenNextError(arg));
if (error2.logLevel < getOpenNextErrorLogLevel()) {
return;
}
if (error2.logLevel === 0) {
return console.log(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
}
if (error2.logLevel === 1) {
return warn(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
}
return console.error(...args);
}
console.error(...args);
}
function getOpenNextErrorLogLevel() {
const strLevel = process.env.OPEN_NEXT_ERROR_LOG_LEVEL ?? "1";
switch (strLevel.toLowerCase()) {
case "debug":
case "0":
return 0;
case "error":
case "2":
return 2;
default:
return 1;
}
}
// ../../node_modules/@opennextjs/aws/dist/utils/cache.js
async function hasBeenRevalidated(key, tags, cacheEntry) {
if (globalThis.openNextConfig.dangerous?.disableTagCache) {
return false;
}
const value = cacheEntry.value;
if (!value) {
return true;
}
if ("type" in cacheEntry && cacheEntry.type === "page") {
return false;
}
const lastModified = cacheEntry.lastModified ?? Date.now();
if (globalThis.tagCache.mode === "nextMode") {
return await globalThis.tagCache.hasBeenRevalidated(tags, lastModified);
}
const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
return _lastModified === -1;
}
function getTagsFromValue(value) {
if (!value) {
return [];
}
try {
return value.meta?.headers?.["x-next-cache-tags"]?.split(",") ?? [];
} catch (e) {
return [];
}
}
function getTagKey(tag) {
if (typeof tag === "string") {
return tag;
}
return JSON.stringify({
tag: tag.tag,
path: tag.path
});
}
async function writeTags(tags) {
const store = globalThis.__openNextAls.getStore();
debug("Writing tags", tags, store);
if (!store || globalThis.openNextConfig.dangerous?.disableTagCache) {
return;
}
const tagsToWrite = tags.filter((t) => {
const tagKey = getTagKey(t);
const shouldWrite = !store.writtenTags.has(tagKey);
if (shouldWrite) {
store.writtenTags.add(tagKey);
}
return shouldWrite;
});
if (tagsToWrite.length === 0) {
return;
}
await globalThis.tagCache.writeTags(tagsToWrite);
}
// ../../node_modules/@opennextjs/aws/dist/utils/binary.js
var commonBinaryMimeTypes = /* @__PURE__ */ new Set([
"application/octet-stream",
// Docs
"application/epub+zip",
"application/msword",
"application/pdf",
"application/rtf",
"application/vnd.amazon.ebook",
"application/vnd.ms-excel",
"application/vnd.ms-powerpoint",
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
// Fonts
"font/otf",
"font/woff",
"font/woff2",
// Images
"image/bmp",
"image/gif",
"image/jpeg",
"image/png",
"image/tiff",
"image/vnd.microsoft.icon",
"image/webp",
// Audio
"audio/3gpp",
"audio/aac",
"audio/basic",
"audio/flac",
"audio/mpeg",
"audio/ogg",
"audio/wavaudio/webm",
"audio/x-aiff",
"audio/x-midi",
"audio/x-wav",
// Video
"video/3gpp",
"video/mp2t",
"video/mpeg",
"video/ogg",
"video/quicktime",
"video/webm",
"video/x-msvideo",
// Archives
"application/java-archive",
"application/vnd.apple.installer+xml",
"application/x-7z-compressed",
"application/x-apple-diskimage",
"application/x-bzip",
"application/x-bzip2",
"application/x-gzip",
"application/x-java-archive",
"application/x-rar-compressed",
"application/x-tar",
"application/x-zip",
"application/zip",
// Serialized data
"application/x-protobuf"
]);
function isBinaryContentType(contentType) {
if (!contentType)
return false;
const value = contentType?.split(";")[0] ?? "";
return commonBinaryMimeTypes.has(value);
}
// ../../node_modules/@opennextjs/aws/dist/adapters/cache.js
function isFetchCache(options) {
if (typeof options === "boolean") {
return options;
}
if (typeof options === "object") {
return options.kindHint === "fetch" || options.fetchCache || options.kind === "FETCH";
}
return false;
}
var Cache = class {
async get(key, options) {
if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
return null;
}
const softTags = typeof options === "object" ? options.softTags : [];
const tags = typeof options === "object" ? options.tags : [];
return isFetchCache(options) ? this.getFetchCache(key, softTags, tags) : this.getIncrementalCache(key);
}
async getFetchCache(key, softTags, tags) {
debug("get fetch cache", { key, softTags, tags });
try {
const cachedEntry = await globalThis.incrementalCache.get(key, "fetch");
if (cachedEntry?.value === void 0)
return null;
const _tags = [...tags ?? [], ...softTags ?? []];
const _lastModified = cachedEntry.lastModified ?? Date.now();
const _hasBeenRevalidated = await hasBeenRevalidated(key, _tags, cachedEntry);
if (_hasBeenRevalidated)
return null;
if ((tags ?? []).length === 0) {
const path = softTags?.find((tag) => tag.startsWith("_N_T_/") && !tag.endsWith("layout") && !tag.endsWith("page"));
if (path) {
const hasPathBeenUpdated = await hasBeenRevalidated(path.replace("_N_T_/", ""), [], cachedEntry);
if (hasPathBeenUpdated) {
return null;
}
}
}
return {
lastModified: _lastModified,
value: cachedEntry.value
};
} catch (e) {
debug("Failed to get fetch cache", e);
return null;
}
}
async getIncrementalCache(key) {
try {
const cachedEntry = await globalThis.incrementalCache.get(key, "cache");
if (!cachedEntry?.value) {
return null;
}
const cacheData = cachedEntry.value;
const meta = cacheData.meta;
const tags = getTagsFromValue(cacheData);
const _lastModified = cachedEntry.lastModified ?? Date.now();
const _hasBeenRevalidated = await hasBeenRevalidated(key, tags, cachedEntry);
if (_hasBeenRevalidated)
return null;
const store = globalThis.__openNextAls.getStore();
if (store) {
store.lastModified = _lastModified;
}
if (cacheData?.type === "route") {
return {
lastModified: _lastModified,
value: {
kind: globalThis.isNextAfter15 ? "APP_ROUTE" : "ROUTE",
body: Buffer.from(cacheData.body ?? Buffer.alloc(0), isBinaryContentType(String(meta?.headers?.["content-type"])) ? "base64" : "utf8"),
status: meta?.status,
headers: meta?.headers
}
};
}
if (cacheData?.type === "page" || cacheData?.type === "app") {
if (globalThis.isNextAfter15 && cacheData?.type === "app") {
return {
lastModified: _lastModified,
value: {
kind: "APP_PAGE",
html: cacheData.html,
rscData: Buffer.from(cacheData.rsc),
status: meta?.status,
headers: meta?.headers,
postponed: meta?.postponed
}
};
}
return {
lastModified: _lastModified,
value: {
kind: globalThis.isNextAfter15 ? "PAGES" : "PAGE",
html: cacheData.html,
pageData: cacheData.type === "page" ? cacheData.json : cacheData.rsc,
status: meta?.status,
headers: meta?.headers
}
};
}
if (cacheData?.type === "redirect") {
return {
lastModified: _lastModified,
value: {
kind: "REDIRECT",
props: cacheData.props
}
};
}
warn("Unknown cache type", cacheData);
return null;
} catch (e) {
debug("Failed to get body cache", e);
return null;
}
}
async set(key, data, ctx) {
if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
return;
}
const detachedPromise = globalThis.__openNextAls.getStore()?.pendingPromiseRunner.withResolvers();
try {
if (data === null || data === void 0) {
await globalThis.incrementalCache.delete(key);
} else {
const revalidate = this.extractRevalidateForSet(ctx);
switch (data.kind) {
case "ROUTE":
case "APP_ROUTE": {
const { body, status, headers } = data;
await globalThis.incrementalCache.set(key, {
type: "route",
body: body.toString(isBinaryContentType(String(headers["content-type"])) ? "base64" : "utf8"),
meta: {
status,
headers
},
revalidate
}, "cache");
break;
}
case "PAGE":
case "PAGES": {
const { html, pageData, status, headers } = data;
const isAppPath = typeof pageData === "string";
if (isAppPath) {
await globalThis.incrementalCache.set(key, {
type: "app",
html,
rsc: pageData,
meta: {
status,
headers
},
revalidate
}, "cache");
} else {
await globalThis.incrementalCache.set(key, {
type: "page",
html,
json: pageData,
revalidate
}, "cache");
}
break;
}
case "APP_PAGE": {
const { html, rscData, headers, status } = data;
await globalThis.incrementalCache.set(key, {
type: "app",
html,
rsc: rscData.toString("utf8"),
meta: {
status,
headers
},
revalidate
}, "cache");
break;
}
case "FETCH":
await globalThis.incrementalCache.set(key, data, "fetch");
break;
case "REDIRECT":
await globalThis.incrementalCache.set(key, {
type: "redirect",
props: data.props,
revalidate
}, "cache");
break;
case "IMAGE":
break;
}
}
await this.updateTagsOnSet(key, data, ctx);
debug("Finished setting cache");
} catch (e) {
error("Failed to set cache", e);
} finally {
detachedPromise?.resolve();
}
}
async revalidateTag(tags) {
const config = globalThis.openNextConfig.dangerous;
if (config?.disableTagCache || config?.disableIncrementalCache) {
return;
}
const _tags = Array.isArray(tags) ? tags : [tags];
if (_tags.length === 0) {
return;
}
try {
if (globalThis.tagCache.mode === "nextMode") {
const paths = await globalThis.tagCache.getPathsByTags?.(_tags) ?? [];
await writeTags(_tags);
if (paths.length > 0) {
await globalThis.cdnInvalidationHandler.invalidatePaths(paths.map((path) => ({
initialPath: path,
rawPath: path,
resolvedRoutes: [
{
route: path,
// TODO: ideally here we should check if it's an app router page or route
type: "app"
}
]
})));
}
return;
}
for (const tag of _tags) {
debug("revalidateTag", tag);
const paths = await globalThis.tagCache.getByTag(tag);
debug("Items", paths);
const toInsert = paths.map((path) => ({
path,
tag
}));
if (tag.startsWith("_N_T_/")) {
for (const path of paths) {
const _tags2 = await globalThis.tagCache.getByPath(path);
const hardTags = _tags2.filter((t) => !t.startsWith("_N_T_/"));
for (const hardTag of hardTags) {
const _paths = await globalThis.tagCache.getByTag(hardTag);
debug({ hardTag, _paths });
toInsert.push(..._paths.map((path2) => ({
path: path2,
tag: hardTag
})));
}
}
}
await writeTags(toInsert);
const uniquePaths = Array.from(new Set(toInsert.filter((t) => t.tag.startsWith("_N_T_/")).map((t) => `/${t.path}`)));
if (uniquePaths.length > 0) {
await globalThis.cdnInvalidationHandler.invalidatePaths(uniquePaths.map((path) => ({
initialPath: path,
rawPath: path,
resolvedRoutes: [
{
route: path,
// TODO: ideally here we should check if it's an app router page or route
type: "app"
}
]
})));
}
}
} catch (e) {
error("Failed to revalidate tag", e);
}
}
// TODO: We should delete/update tags in this method
// This will require an update to the tag cache interface
async updateTagsOnSet(key, data, ctx) {
if (globalThis.openNextConfig.dangerous?.disableTagCache || globalThis.tagCache.mode === "nextMode" || // Here it means it's a delete
!data) {
return;
}
const derivedTags = data?.kind === "FETCH" ? (
//@ts-expect-error - On older versions of next, ctx was a number, but for these cases we use data?.data?.tags
ctx?.tags ?? data?.data?.tags ?? []
) : data?.kind === "PAGE" ? data.headers?.["x-next-cache-tags"]?.split(",") ?? [] : [];
debug("derivedTags", derivedTags);
const storedTags = await globalThis.tagCache.getByPath(key);
const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
if (tagsToWrite.length > 0) {
await writeTags(tagsToWrite.map((tag) => ({
path: key,
tag,
// In case the tags are not there we just need to create them
// but we don't want them to return from `getLastModified` as they are not stale
revalidatedAt: 1
})));
}
}
extractRevalidateForSet(ctx) {
if (ctx === void 0) {
return void 0;
}
if (typeof ctx === "number" || ctx === false) {
return ctx;
}
if ("revalidate" in ctx) {
return ctx.revalidate;
}
if ("cacheControl" in ctx) {
return ctx.cacheControl?.revalidate;
}
return void 0;
}
};

169
apps/web/.open-next/.build/composable-cache.cjs Normal file
View File

@@ -0,0 +1,169 @@
globalThis.disableIncrementalCache = false;globalThis.disableDynamoDBCache = false;globalThis.isNextAfter15 = true;globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.0";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ../../node_modules/@opennextjs/aws/dist/adapters/composable-cache.js
var composable_cache_exports = {};
__export(composable_cache_exports, {
default: () => composable_cache_default
});
module.exports = __toCommonJS(composable_cache_exports);
// ../../node_modules/@opennextjs/aws/dist/adapters/logger.js
function debug(...args) {
if (globalThis.openNextDebug) {
console.log(...args);
}
}
// ../../node_modules/@opennextjs/aws/dist/utils/cache.js
function getTagKey(tag) {
if (typeof tag === "string") {
return tag;
}
return JSON.stringify({
tag: tag.tag,
path: tag.path
});
}
async function writeTags(tags) {
const store = globalThis.__openNextAls.getStore();
debug("Writing tags", tags, store);
if (!store || globalThis.openNextConfig.dangerous?.disableTagCache) {
return;
}
const tagsToWrite = tags.filter((t) => {
const tagKey = getTagKey(t);
const shouldWrite = !store.writtenTags.has(tagKey);
if (shouldWrite) {
store.writtenTags.add(tagKey);
}
return shouldWrite;
});
if (tagsToWrite.length === 0) {
return;
}
await globalThis.tagCache.writeTags(tagsToWrite);
}
// ../../node_modules/@opennextjs/aws/dist/utils/stream.js
var import_node_stream = require("node:stream");
function fromReadableStream(stream, base64) {
const reader = stream.getReader();
const chunks = [];
return new Promise((resolve, reject) => {
function pump() {
reader.read().then(({ done, value }) => {
if (done) {
resolve(Buffer.concat(chunks).toString(base64 ? "base64" : "utf8"));
return;
}
chunks.push(value);
pump();
}).catch(reject);
}
pump();
});
}
function toReadableStream(value, isBase64) {
return import_node_stream.Readable.toWeb(import_node_stream.Readable.from(Buffer.from(value, isBase64 ? "base64" : "utf8")));
}
// ../../node_modules/@opennextjs/aws/dist/adapters/composable-cache.js
var pendingWritePromiseMap = /* @__PURE__ */ new Map();
var composable_cache_default = {
async get(cacheKey) {
try {
if (pendingWritePromiseMap.has(cacheKey)) {
return pendingWritePromiseMap.get(cacheKey);
}
const result = await globalThis.incrementalCache.get(cacheKey, "composable");
if (!result?.value?.value) {
return void 0;
}
debug("composable cache result", result);
if (globalThis.tagCache.mode === "nextMode" && result.value.tags.length > 0) {
const hasBeenRevalidated = await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
if (hasBeenRevalidated)
return void 0;
} else if (globalThis.tagCache.mode === "original" || globalThis.tagCache.mode === void 0) {
const hasBeenRevalidated = await globalThis.tagCache.getLastModified(cacheKey, result.lastModified) === -1;
if (hasBeenRevalidated)
return void 0;
}
return {
...result.value,
value: toReadableStream(result.value.value)
};
} catch (e) {
debug("Cannot read composable cache entry");
return void 0;
}
},
async set(cacheKey, pendingEntry) {
pendingWritePromiseMap.set(cacheKey, pendingEntry);
const entry = await pendingEntry.finally(() => {
pendingWritePromiseMap.delete(cacheKey);
});
const valueToStore = await fromReadableStream(entry.value);
await globalThis.incrementalCache.set(cacheKey, {
...entry,
value: valueToStore
}, "composable");
if (globalThis.tagCache.mode === "original") {
const storedTags = await globalThis.tagCache.getByPath(cacheKey);
const tagsToWrite = entry.tags.filter((tag) => !storedTags.includes(tag));
if (tagsToWrite.length > 0) {
await writeTags(tagsToWrite.map((tag) => ({ tag, path: cacheKey })));
}
}
},
async refreshTags() {
return;
},
async getExpiration(...tags) {
if (globalThis.tagCache.mode === "nextMode") {
return globalThis.tagCache.getLastRevalidated(tags);
}
return 0;
},
async expireTags(...tags) {
if (globalThis.tagCache.mode === "nextMode") {
return writeTags(tags);
}
const tagCache = globalThis.tagCache;
const revalidatedAt = Date.now();
const pathsToUpdate = await Promise.all(tags.map(async (tag) => {
const paths = await tagCache.getByTag(tag);
return paths.map((path) => ({
path,
tag,
revalidatedAt
}));
}));
const setToWrite = /* @__PURE__ */ new Set();
for (const entry of pathsToUpdate.flat()) {
setToWrite.add(entry);
}
await writeTags(Array.from(setToWrite));
},
// This one is necessary for older versions of next
async receiveExpiredTags(...tags) {
return;
}
};

104
apps/web/.open-next/.build/durable-objects/bucket-cache-purge.js Normal file
View File

@@ -0,0 +1,104 @@
globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.0";
// ../../node_modules/@opennextjs/cloudflare/dist/api/durable-objects/bucket-cache-purge.js
import { DurableObject } from "cloudflare:workers";
// ../../node_modules/@opennextjs/cloudflare/dist/api/cloudflare-context.js
var cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
// ../../node_modules/@opennextjs/cloudflare/dist/api/overrides/internal.js
var debugCache = (name, ...args) => {
if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
console.log(`[${name}] `, ...args);
}
};
async function internalPurgeCacheByTags(env, tags) {
if (!env.CACHE_PURGE_ZONE_ID && !env.CACHE_PURGE_API_TOKEN) {
debugCache("purgeCacheByTags", "No cache zone ID or API token provided. Skipping cache purge.");
return "missing-credentials";
}
try {
const response = await fetch(`https://api.cloudflare.com/client/v4/zones/${env.CACHE_PURGE_ZONE_ID}/purge_cache`, {
headers: {
Authorization: `Bearer ${env.CACHE_PURGE_API_TOKEN}`,
"Content-Type": "application/json"
},
method: "POST",
body: JSON.stringify({
tags
})
});
if (response.status === 429) {
debugCache("purgeCacheByTags", "Rate limit exceeded. Skipping cache purge.");
return "rate-limit-exceeded";
}
const bodyResponse = await response.json();
if (!bodyResponse.success) {
debugCache("purgeCacheByTags", "Cache purge failed. Errors:", bodyResponse.errors.map((error) => `${error.code}: ${error.message}`));
return "purge-failed";
}
debugCache("purgeCacheByTags", "Cache purged successfully for tags:", tags);
return "purge-success";
} catch (error) {
console.error("Error purging cache by tags:", error);
return "purge-failed";
}
}
// ../../node_modules/@opennextjs/cloudflare/dist/api/durable-objects/bucket-cache-purge.js
var DEFAULT_BUFFER_TIME_IN_SECONDS = 5;
var MAX_NUMBER_OF_TAGS_PER_PURGE = 100;
var BucketCachePurge = class extends DurableObject {
bufferTimeInSeconds;
constructor(state, env) {
super(state, env);
this.bufferTimeInSeconds = env.NEXT_CACHE_DO_PURGE_BUFFER_TIME_IN_SECONDS ? parseInt(env.NEXT_CACHE_DO_PURGE_BUFFER_TIME_IN_SECONDS) : DEFAULT_BUFFER_TIME_IN_SECONDS;
state.blockConcurrencyWhile(async () => {
state.storage.sql.exec(`
CREATE TABLE IF NOT EXISTS cache_purge (
tag TEXT NOT NULL
);
CREATE UNIQUE INDEX IF NOT EXISTS tag_index ON cache_purge (tag);
`);
});
}
async purgeCacheByTags(tags) {
for (const tag of tags) {
this.ctx.storage.sql.exec(`
INSERT OR REPLACE INTO cache_purge (tag)
VALUES (?)`, [tag]);
}
const nextAlarm = await this.ctx.storage.getAlarm();
if (!nextAlarm) {
this.ctx.storage.setAlarm(Date.now() + this.bufferTimeInSeconds * 1e3);
}
}
async alarm() {
let tags = this.ctx.storage.sql.exec(`
SELECT * FROM cache_purge LIMIT ${MAX_NUMBER_OF_TAGS_PER_PURGE}
`).toArray();
do {
if (tags.length === 0) {
return;
}
const result = await internalPurgeCacheByTags(this.env, tags.map((row) => row.tag));
if (result === "rate-limit-exceeded") {
throw new Error("Rate limit exceeded");
}
this.ctx.storage.sql.exec(`
DELETE FROM cache_purge
WHERE tag IN (${tags.map(() => "?").join(",")})
`, tags.map((row) => row.tag));
if (tags.length < MAX_NUMBER_OF_TAGS_PER_PURGE) {
tags = [];
} else {
tags = this.ctx.storage.sql.exec(`
SELECT * FROM cache_purge LIMIT ${MAX_NUMBER_OF_TAGS_PER_PURGE}
`).toArray();
}
} while (tags.length >= 0);
}
};
export {
BucketCachePurge
};

278
apps/web/.open-next/.build/durable-objects/queue.js Normal file
View File

@@ -0,0 +1,278 @@
globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.0";
// ../../node_modules/@opennextjs/aws/dist/utils/error.js
var IgnorableError = class extends Error {
__openNextInternal = true;
canIgnore = true;
logLevel = 0;
constructor(message) {
super(message);
this.name = "IgnorableError";
}
};
var RecoverableError = class extends Error {
__openNextInternal = true;
canIgnore = true;
logLevel = 1;
constructor(message) {
super(message);
this.name = "RecoverableError";
}
};
var FatalError = class extends Error {
__openNextInternal = true;
canIgnore = false;
logLevel = 2;
constructor(message) {
super(message);
this.name = "FatalError";
}
};
function isOpenNextError(e) {
try {
return "__openNextInternal" in e;
} catch {
return false;
}
}
// ../../node_modules/@opennextjs/aws/dist/adapters/logger.js
function debug(...args) {
if (globalThis.openNextDebug) {
console.log(...args);
}
}
function warn(...args) {
console.warn(...args);
}
var DOWNPLAYED_ERROR_LOGS = [
{
clientName: "S3Client",
commandName: "GetObjectCommand",
errorName: "NoSuchKey"
}
];
var isDownplayedErrorLog = (errorLog) => DOWNPLAYED_ERROR_LOGS.some((downplayedInput) => downplayedInput.clientName === errorLog?.clientName && downplayedInput.commandName === errorLog?.commandName && (downplayedInput.errorName === errorLog?.error?.name || downplayedInput.errorName === errorLog?.error?.Code));
function error(...args) {
if (args.some((arg) => isDownplayedErrorLog(arg))) {
return debug(...args);
}
if (args.some((arg) => isOpenNextError(arg))) {
const error2 = args.find((arg) => isOpenNextError(arg));
if (error2.logLevel < getOpenNextErrorLogLevel()) {
return;
}
if (error2.logLevel === 0) {
return console.log(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
}
if (error2.logLevel === 1) {
return warn(...args.map((arg) => isOpenNextError(arg) ? `${arg.name}: ${arg.message}` : arg));
}
return console.error(...args);
}
console.error(...args);
}
function getOpenNextErrorLogLevel() {
const strLevel = process.env.OPEN_NEXT_ERROR_LOG_LEVEL ?? "1";
switch (strLevel.toLowerCase()) {
case "debug":
case "0":
return 0;
case "error":
case "2":
return 2;
default:
return 1;
}
}
// ../../node_modules/@opennextjs/cloudflare/dist/api/durable-objects/queue.js
import { DurableObject } from "cloudflare:workers";
var DEFAULT_MAX_REVALIDATION = 5;
var DEFAULT_REVALIDATION_TIMEOUT_MS = 1e4;
var DEFAULT_RETRY_INTERVAL_MS = 2e3;
var DEFAULT_MAX_RETRIES = 6;
var DOQueueHandler = class extends DurableObject {
// Ongoing revalidations are deduped by the deduplication id
// Since this is running in waitUntil, we expect the durable object state to persist this during the duration of the revalidation
// TODO: handle incremental cache with only eventual consistency (i.e. KV or R2/D1 with the optional cache layer on top)
ongoingRevalidations = /* @__PURE__ */ new Map();
sql;
routeInFailedState = /* @__PURE__ */ new Map();
service;
// Configurable params
maxRevalidations;
revalidationTimeout;
revalidationRetryInterval;
maxRetries;
disableSQLite;
constructor(ctx, env) {
super(ctx, env);
this.service = env.WORKER_SELF_REFERENCE;
if (!this.service)
throw new IgnorableError("No service binding for cache revalidation worker");
this.sql = ctx.storage.sql;
this.maxRevalidations = env.NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION) : DEFAULT_MAX_REVALIDATION;
this.revalidationTimeout = env.NEXT_CACHE_DO_QUEUE_REVALIDATION_TIMEOUT_MS ? parseInt(env.NEXT_CACHE_DO_QUEUE_REVALIDATION_TIMEOUT_MS) : DEFAULT_REVALIDATION_TIMEOUT_MS;
this.revalidationRetryInterval = env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS ? parseInt(env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS) : DEFAULT_RETRY_INTERVAL_MS;
this.maxRetries = env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES) : DEFAULT_MAX_RETRIES;
this.disableSQLite = env.NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE === "true";
ctx.blockConcurrencyWhile(async () => {
debug(`Restoring the state of the durable object`);
await this.initState();
});
debug(`Durable object initialized`);
}
async revalidate(msg) {
if (this.ongoingRevalidations.size > 2 * this.maxRevalidations) {
warn(`Your durable object has 2 times the maximum number of revalidations (${this.maxRevalidations}) in progress. If this happens often, you should consider increasing the NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION or the number of durable objects with the MAX_REVALIDATE_CONCURRENCY env var.`);
}
if (this.ongoingRevalidations.has(msg.MessageDeduplicationId))
return;
if (this.routeInFailedState.has(msg.MessageDeduplicationId))
return;
if (this.checkSyncTable(msg))
return;
if (this.ongoingRevalidations.size >= this.maxRevalidations) {
debug(`The maximum number of revalidations (${this.maxRevalidations}) is reached. Blocking until one of the revalidations finishes.`);
while (this.ongoingRevalidations.size >= this.maxRevalidations) {
const ongoingRevalidations = this.ongoingRevalidations.values();
debug(`Waiting for one of the revalidations to finish`);
await Promise.race(ongoingRevalidations);
}
}
const revalidationPromise = this.executeRevalidation(msg);
this.ongoingRevalidations.set(msg.MessageDeduplicationId, revalidationPromise);
this.ctx.waitUntil(revalidationPromise);
}
async executeRevalidation(msg) {
try {
debug(`Revalidating ${msg.MessageBody.host}${msg.MessageBody.url}`);
const { MessageBody: { host, url } } = msg;
const protocol = host.includes("localhost") ? "http" : "https";
const response = await this.service.fetch(`${protocol}://${host}${url}`, {
method: "HEAD",
headers: {
// This is defined during build
"x-prerender-revalidate": "b2762359d1edbb5696c7c29077489c05",
"x-isr": "1"
},
// This one is kind of problematic, it will always show the wall time of the revalidation to `this.revalidationTimeout`
signal: AbortSignal.timeout(this.revalidationTimeout)
});
if (response.status === 200 && response.headers.get("x-nextjs-cache") !== "REVALIDATED") {
this.routeInFailedState.delete(msg.MessageDeduplicationId);
throw new FatalError(`The revalidation for ${host}${url} cannot be done. This error should never happen.`);
} else if (response.status === 404) {
this.routeInFailedState.delete(msg.MessageDeduplicationId);
throw new IgnorableError(`The revalidation for ${host}${url} cannot be done because the page is not found. It's either expected or an error in user code itself`);
} else if (response.status === 500) {
await this.addToFailedState(msg);
throw new IgnorableError(`Something went wrong while revalidating ${host}${url}`);
} else if (response.status !== 200) {
await this.addToFailedState(msg);
throw new RecoverableError(`An unknown error occurred while revalidating ${host}${url}`);
}
if (!this.disableSQLite) {
this.sql.exec(
"INSERT OR REPLACE INTO sync (id, lastSuccess, buildId) VALUES (?, unixepoch(), ?)",
// We cannot use the deduplication id because it's not unique per route - every time a route is revalidated, the deduplication id is different.
`${host}${url}`,
"pYUMJqQmqlh8C9DCzFGyK"
);
}
this.routeInFailedState.delete(msg.MessageDeduplicationId);
} catch (e) {
if (!isOpenNextError(e)) {
await this.addToFailedState(msg);
}
error(e);
} finally {
this.ongoingRevalidations.delete(msg.MessageDeduplicationId);
}
}
async alarm() {
const currentDateTime = Date.now();
const nextEventToRetry = Array.from(this.routeInFailedState.values()).filter(({ nextAlarmMs }) => nextAlarmMs > currentDateTime).sort(({ nextAlarmMs: a }, { nextAlarmMs: b }) => a - b)[0];
const expiredEvents = Array.from(this.routeInFailedState.values()).filter(({ nextAlarmMs }) => nextAlarmMs <= currentDateTime);
const allEventsToRetry = nextEventToRetry ? [nextEventToRetry, ...expiredEvents] : expiredEvents;
for (const event of allEventsToRetry) {
debug(`Retrying revalidation for ${event.msg.MessageBody.host}${event.msg.MessageBody.url}`);
await this.executeRevalidation(event.msg);
}
}
async addToFailedState(msg) {
debug(`Adding ${msg.MessageBody.host}${msg.MessageBody.url} to the failed state`);
const existingFailedState = this.routeInFailedState.get(msg.MessageDeduplicationId);
let updatedFailedState;
if (existingFailedState) {
if (existingFailedState.retryCount >= this.maxRetries) {
error(`The revalidation for ${msg.MessageBody.host}${msg.MessageBody.url} has failed after ${this.maxRetries} retries. It will not be tried again, but subsequent ISR requests will retry.`);
this.routeInFailedState.delete(msg.MessageDeduplicationId);
return;
}
const nextAlarmMs = Date.now() + Math.pow(2, existingFailedState.retryCount + 1) * this.revalidationRetryInterval;
updatedFailedState = {
...existingFailedState,
retryCount: existingFailedState.retryCount + 1,
nextAlarmMs
};
} else {
updatedFailedState = {
msg,
retryCount: 1,
nextAlarmMs: Date.now() + 2e3
};
}
this.routeInFailedState.set(msg.MessageDeduplicationId, updatedFailedState);
if (!this.disableSQLite) {
this.sql.exec("INSERT OR REPLACE INTO failed_state (id, data, buildId) VALUES (?, ?, ?)", msg.MessageDeduplicationId, JSON.stringify(updatedFailedState), "pYUMJqQmqlh8C9DCzFGyK");
}
await this.addAlarm();
}
async addAlarm() {
const existingAlarm = await this.ctx.storage.getAlarm({ allowConcurrency: false });
if (existingAlarm)
return;
if (this.routeInFailedState.size === 0)
return;
let nextAlarmToSetup = Math.min(...Array.from(this.routeInFailedState.values()).map(({ nextAlarmMs }) => nextAlarmMs));
if (nextAlarmToSetup < Date.now()) {
nextAlarmToSetup = Date.now() + this.revalidationRetryInterval;
}
await this.ctx.storage.setAlarm(nextAlarmToSetup);
}
// This function is used to restore the state of the durable object
// We don't restore the ongoing revalidations because we cannot know in which state they are
// We only restore the failed state and the alarm
async initState() {
if (this.disableSQLite)
return;
this.sql.exec("CREATE TABLE IF NOT EXISTS failed_state (id TEXT PRIMARY KEY, data TEXT, buildId TEXT)");
this.sql.exec("CREATE TABLE IF NOT EXISTS sync (id TEXT PRIMARY KEY, lastSuccess INTEGER, buildId TEXT)");
this.sql.exec("DELETE FROM failed_state WHERE buildId != ?", "pYUMJqQmqlh8C9DCzFGyK");
this.sql.exec("DELETE FROM sync WHERE buildId != ?", "pYUMJqQmqlh8C9DCzFGyK");
const failedStateCursor = this.sql.exec("SELECT * FROM failed_state");
for (const row of failedStateCursor) {
this.routeInFailedState.set(row.id, JSON.parse(row.data));
}
await this.addAlarm();
}
/**
*
* @param msg
* @returns `true` if the route has been revalidated since the lastModified from the message, `false` otherwise
*/
checkSyncTable(msg) {
try {
if (this.disableSQLite)
return false;
return this.sql.exec("SELECT 1 FROM sync WHERE id = ? AND lastSuccess > ? LIMIT 1", `${msg.MessageBody.host}${msg.MessageBody.url}`, Math.round(msg.MessageBody.lastModified / 1e3)).toArray().length > 0;
} catch {
return false;
}
}
};
export {
DOQueueHandler
};

36
apps/web/.open-next/.build/durable-objects/sharded-tag-cache.js Normal file
View File

@@ -0,0 +1,36 @@
globalThis.openNextDebug = false;globalThis.openNextVersion = "3.7.0";
// ../../node_modules/@opennextjs/cloudflare/dist/api/durable-objects/sharded-tag-cache.js
import { DurableObject } from "cloudflare:workers";
var DOShardedTagCache = class extends DurableObject {
sql;
constructor(state, env) {
super(state, env);
this.sql = state.storage.sql;
state.blockConcurrencyWhile(async () => {
this.sql.exec(`CREATE TABLE IF NOT EXISTS revalidations (tag TEXT PRIMARY KEY, revalidatedAt INTEGER)`);
});
}
async getLastRevalidated(tags) {
try {
const result = this.sql.exec(`SELECT MAX(revalidatedAt) AS time FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")})`, ...tags).toArray();
if (result.length === 0)
return 0;
return result[0]?.time;
} catch (e) {
console.error(e);
return 0;
}
}
async hasBeenRevalidated(tags, lastModified) {
return this.sql.exec(`SELECT 1 FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`, ...tags, lastModified ?? Date.now()).toArray().length > 0;
}
async writeTags(tags, lastModified) {
tags.forEach((tag) => {
this.sql.exec(`INSERT OR REPLACE INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`, tag, lastModified);
});
}
};
export {
DOShardedTagCache
};

205
apps/web/.open-next/.build/open-next.config.edge.mjs Normal file
View File

@@ -0,0 +1,205 @@
// ../../node_modules/@opennextjs/cloudflare/dist/api/cloudflare-context.js
var cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
function getCloudflareContext(options = { async: false }) {
return options.async ? getCloudflareContextAsync() : getCloudflareContextSync();
}
function getCloudflareContextFromGlobalScope() {
const global = globalThis;
return global[cloudflareContextSymbol];
}
function inSSG() {
const global = globalThis;
return global.__NEXT_DATA__?.nextExport === true;
}
function getCloudflareContextSync() {
const cloudflareContext = getCloudflareContextFromGlobalScope();
if (cloudflareContext) {
return cloudflareContext;
}
if (inSSG()) {
throw new Error(`
ERROR: \`getCloudflareContext\` has been called in sync mode in either a static route or at the top level of a non-static one, both cases are not allowed but can be solved by either:
- make sure that the call is not at the top level and that the route is not static
- call \`getCloudflareContext({async: true})\` to use the \`async\` mode
- avoid calling \`getCloudflareContext\` in the route
`);
}
throw new Error(initOpenNextCloudflareForDevErrorMsg);
}
async function getCloudflareContextAsync() {
const cloudflareContext = getCloudflareContextFromGlobalScope();
if (cloudflareContext) {
return cloudflareContext;
}
const inNodejsRuntime = process.env.NEXT_RUNTIME === "nodejs";
if (inNodejsRuntime || inSSG()) {
const cloudflareContext2 = await getCloudflareContextFromWrangler();
addCloudflareContextToNodejsGlobal(cloudflareContext2);
return cloudflareContext2;
}
throw new Error(initOpenNextCloudflareForDevErrorMsg);
}
function addCloudflareContextToNodejsGlobal(cloudflareContext) {
const global = globalThis;
global[cloudflareContextSymbol] = cloudflareContext;
}
async function getCloudflareContextFromWrangler(options) {
const { getPlatformProxy } = await import(
/* webpackIgnore: true */
`${"__wrangler".replaceAll("_", "")}`
);
const environment = options?.environment ?? process.env.NEXT_DEV_WRANGLER_ENV;
const { env, cf, ctx } = await getPlatformProxy({
...options,
environment
});
return {
env,
cf,
ctx
};
}
var initOpenNextCloudflareForDevErrorMsg = `
ERROR: \`getCloudflareContext\` has been called without having called \`initOpenNextCloudflareForDev\` from the Next.js config file.
You should update your Next.js config file as shown below:
\`\`\`
// next.config.mjs
import { initOpenNextCloudflareForDev } from "@opennextjs/cloudflare";
initOpenNextCloudflareForDev();
const nextConfig = { ... };
export default nextConfig;
\`\`\`
`;
// ../../node_modules/@opennextjs/cloudflare/dist/api/overrides/asset-resolver/index.js
var resolver = {
name: "cloudflare-asset-resolver",
async maybeGetAssetResult(event) {
const { ASSETS } = getCloudflareContext().env;
if (!ASSETS || !isUserWorkerFirst(globalThis.__ASSETS_RUN_WORKER_FIRST__, event.rawPath)) {
return void 0;
}
const { method, headers } = event;
if (method !== "GET" && method != "HEAD") {
return void 0;
}
const url = new URL(event.rawPath, "https://assets.local");
const response = await ASSETS.fetch(url, {
headers,
method
});
if (response.status === 404) {
return void 0;
}
return {
type: "core",
statusCode: response.status,
headers: Object.fromEntries(response.headers.entries()),
// Workers and Node types differ.
// eslint-disable-next-line @typescript-eslint/no-explicit-any
body: response.body || new ReadableStream(),
isBase64Encoded: false
};
}
};
function isUserWorkerFirst(runWorkerFirst, pathname) {
if (!Array.isArray(runWorkerFirst)) {
return runWorkerFirst ?? false;
}
let hasPositiveMatch = false;
for (let rule of runWorkerFirst) {
let isPositiveRule = true;
if (rule.startsWith("!")) {
rule = rule.slice(1);
isPositiveRule = false;
} else if (hasPositiveMatch) {
continue;
}
const match = new RegExp(`^${rule.replace(/([[\]().*+?^$|{}\\])/g, "\\$1").replace("\\*", ".*")}$`).test(pathname);
if (match) {
if (isPositiveRule) {
hasPositiveMatch = true;
} else {
return false;
}
}
}
return hasPositiveMatch;
}
var asset_resolver_default = resolver;
// ../../node_modules/@opennextjs/cloudflare/dist/api/config.js
function defineCloudflareConfig(config = {}) {
const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false, routePreloadingBehavior = "none" } = config;
return {
default: {
override: {
wrapper: "cloudflare-node",
converter: "edge",
proxyExternalRequest: "fetch",
incrementalCache: resolveIncrementalCache(incrementalCache),
tagCache: resolveTagCache(tagCache),
queue: resolveQueue(queue),
cdnInvalidation: resolveCdnInvalidation(cachePurge)
},
routePreloadingBehavior
},
// node:crypto is used to compute cache keys
edgeExternals: ["node:crypto"],
cloudflare: {
useWorkerdCondition: true
},
dangerous: {
enableCacheInterception
},
middleware: {
external: true,
override: {
wrapper: "cloudflare-edge",
converter: "edge",
proxyExternalRequest: "fetch",
incrementalCache: resolveIncrementalCache(incrementalCache),
tagCache: resolveTagCache(tagCache),
queue: resolveQueue(queue)
},
assetResolver: () => asset_resolver_default
}
};
}
function resolveIncrementalCache(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveTagCache(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveQueue(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveCdnInvalidation(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
// open-next.config.ts
var open_next_config_default = defineCloudflareConfig();
export {
open_next_config_default as default
};

207
apps/web/.open-next/.build/open-next.config.mjs Normal file
View File

@@ -0,0 +1,207 @@
import { createRequire as topLevelCreateRequire } from 'module';const require = topLevelCreateRequire(import.meta.url);import bannerUrl from 'url';const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));
// ../../node_modules/@opennextjs/cloudflare/dist/api/cloudflare-context.js
var cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
function getCloudflareContext(options = { async: false }) {
return options.async ? getCloudflareContextAsync() : getCloudflareContextSync();
}
function getCloudflareContextFromGlobalScope() {
const global = globalThis;
return global[cloudflareContextSymbol];
}
function inSSG() {
const global = globalThis;
return global.__NEXT_DATA__?.nextExport === true;
}
function getCloudflareContextSync() {
const cloudflareContext = getCloudflareContextFromGlobalScope();
if (cloudflareContext) {
return cloudflareContext;
}
if (inSSG()) {
throw new Error(`
ERROR: \`getCloudflareContext\` has been called in sync mode in either a static route or at the top level of a non-static one, both cases are not allowed but can be solved by either:
- make sure that the call is not at the top level and that the route is not static
- call \`getCloudflareContext({async: true})\` to use the \`async\` mode
- avoid calling \`getCloudflareContext\` in the route
`);
}
throw new Error(initOpenNextCloudflareForDevErrorMsg);
}
async function getCloudflareContextAsync() {
const cloudflareContext = getCloudflareContextFromGlobalScope();
if (cloudflareContext) {
return cloudflareContext;
}
const inNodejsRuntime = process.env.NEXT_RUNTIME === "nodejs";
if (inNodejsRuntime || inSSG()) {
const cloudflareContext2 = await getCloudflareContextFromWrangler();
addCloudflareContextToNodejsGlobal(cloudflareContext2);
return cloudflareContext2;
}
throw new Error(initOpenNextCloudflareForDevErrorMsg);
}
function addCloudflareContextToNodejsGlobal(cloudflareContext) {
const global = globalThis;
global[cloudflareContextSymbol] = cloudflareContext;
}
async function getCloudflareContextFromWrangler(options) {
const { getPlatformProxy } = await import(
/* webpackIgnore: true */
`${"__wrangler".replaceAll("_", "")}`
);
const environment = options?.environment ?? process.env.NEXT_DEV_WRANGLER_ENV;
const { env, cf, ctx } = await getPlatformProxy({
...options,
environment
});
return {
env,
cf,
ctx
};
}
var initOpenNextCloudflareForDevErrorMsg = `
ERROR: \`getCloudflareContext\` has been called without having called \`initOpenNextCloudflareForDev\` from the Next.js config file.
You should update your Next.js config file as shown below:
\`\`\`
// next.config.mjs
import { initOpenNextCloudflareForDev } from "@opennextjs/cloudflare";
initOpenNextCloudflareForDev();
const nextConfig = { ... };
export default nextConfig;
\`\`\`
`;
// ../../node_modules/@opennextjs/cloudflare/dist/api/overrides/asset-resolver/index.js
var resolver = {
name: "cloudflare-asset-resolver",
async maybeGetAssetResult(event) {
const { ASSETS } = getCloudflareContext().env;
if (!ASSETS || !isUserWorkerFirst(globalThis.__ASSETS_RUN_WORKER_FIRST__, event.rawPath)) {
return void 0;
}
const { method, headers } = event;
if (method !== "GET" && method != "HEAD") {
return void 0;
}
const url = new URL(event.rawPath, "https://assets.local");
const response = await ASSETS.fetch(url, {
headers,
method
});
if (response.status === 404) {
return void 0;
}
return {
type: "core",
statusCode: response.status,
headers: Object.fromEntries(response.headers.entries()),
// Workers and Node types differ.
// eslint-disable-next-line @typescript-eslint/no-explicit-any
body: response.body || new ReadableStream(),
isBase64Encoded: false
};
}
};
function isUserWorkerFirst(runWorkerFirst, pathname) {
if (!Array.isArray(runWorkerFirst)) {
return runWorkerFirst ?? false;
}
let hasPositiveMatch = false;
for (let rule of runWorkerFirst) {
let isPositiveRule = true;
if (rule.startsWith("!")) {
rule = rule.slice(1);
isPositiveRule = false;
} else if (hasPositiveMatch) {
continue;
}
const match = new RegExp(`^${rule.replace(/([[\]().*+?^$|{}\\])/g, "\\$1").replace("\\*", ".*")}$`).test(pathname);
if (match) {
if (isPositiveRule) {
hasPositiveMatch = true;
} else {
return false;
}
}
}
return hasPositiveMatch;
}
var asset_resolver_default = resolver;
// ../../node_modules/@opennextjs/cloudflare/dist/api/config.js
function defineCloudflareConfig(config = {}) {
const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false, routePreloadingBehavior = "none" } = config;
return {
default: {
override: {
wrapper: "cloudflare-node",
converter: "edge",
proxyExternalRequest: "fetch",
incrementalCache: resolveIncrementalCache(incrementalCache),
tagCache: resolveTagCache(tagCache),
queue: resolveQueue(queue),
cdnInvalidation: resolveCdnInvalidation(cachePurge)
},
routePreloadingBehavior
},
// node:crypto is used to compute cache keys
edgeExternals: ["node:crypto"],
cloudflare: {
useWorkerdCondition: true
},
dangerous: {
enableCacheInterception
},
middleware: {
external: true,
override: {
wrapper: "cloudflare-edge",
converter: "edge",
proxyExternalRequest: "fetch",
incrementalCache: resolveIncrementalCache(incrementalCache),
tagCache: resolveTagCache(tagCache),
queue: resolveQueue(queue)
},
assetResolver: () => asset_resolver_default
}
};
}
function resolveIncrementalCache(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveTagCache(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveQueue(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
function resolveCdnInvalidation(value = "dummy") {
if (typeof value === "string") {
return value;
}
return typeof value === "function" ? value : () => value;
}
// open-next.config.ts
var open_next_config_default = defineCloudflareConfig();
export {
open_next_config_default as default
};