@opennextjs/aws 3.2.0 → 3.2.2

package/dist/overrides/converters/aws-apigw-v2.d.ts

@@ -1,3 +1,3 @@
-import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
-declare const _default: Converter<InternalEvent, InternalResult>;
+import type { Converter } from "../../types/overrides";
+declare const _default: Converter;
 export default _default;

package/dist/overrides/converters/aws-apigw-v2.js

@@ -32,21 +32,19 @@ function normalizeAPIGatewayProxyEventV2Body(event) {
     if (Buffer.isBuffer(body)) {
         return body;
     }
-    else if (typeof body === "string") {
+    if (typeof body === "string") {
         return Buffer.from(body, isBase64Encoded ? "base64" : "utf8");
     }
-    else if (typeof body === "object") {
+    if (typeof body === "object") {
         return Buffer.from(JSON.stringify(body));
     }
-    else {
-        return Buffer.from("", "utf8");
-    }
+    return Buffer.from("", "utf8");
 }
 function normalizeAPIGatewayProxyEventV2Headers(event) {
     const { headers: rawHeaders, cookies } = event;
     const headers = {};
     if (Array.isArray(cookies)) {
-        headers["cookie"] = cookies.join("; ");
+        headers.cookie = cookies.join("; ");
     }
     for (const [key, value] of Object.entries(rawHeaders || {})) {
         headers[key.toLowerCase()] = value;
@@ -66,7 +64,8 @@ async function convertFromAPIGatewayProxyEventV2(event) {
         query: removeUndefinedFromQuery(convertToQuery(rawQueryString)),
         cookies: event.cookies?.reduce((acc, cur) => {
             const [key, value] = cur.split("=");
-            return { ...acc, [key]: value };
+            acc[key] = value;
+            return acc;
         }, {}) ?? {},
     };
 }

package/dist/overrides/converters/aws-cloudfront.d.ts

@@ -1,3 +1,3 @@
-import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
-declare const _default: Converter<InternalEvent, InternalResult>;
+import type { Converter } from "../../types/overrides";
+declare const _default: Converter;
 export default _default;

package/dist/overrides/converters/aws-cloudfront.js

@@ -1,8 +1,8 @@
 import { parseCookies } from "../../http/util";
 import { fromReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
-import { convertRes, convertToQuery, convertToQueryString, createServerResponse, proxyRequest, } from "../../core/routing/util";
-const CloudFrontBlacklistedHeaders = [
+import { convertToQuery, convertToQueryString, } from "../../core/routing/util";
+const cloudfrontBlacklistedHeaders = [
     // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
     "connection",
     "expect",
@@ -67,8 +67,9 @@ async function convertFromCloudFrontRequestEvent(event) {
         remoteAddress: clientIp,
         query: convertToQuery(querystring),
         cookies: headers.cookie?.reduce((acc, cur) => {
-            const { key, value } = cur;
-            return { ...acc, [key ?? ""]: value };
+            const { key = "", value } = cur;
+            acc[key] = value;
+            return acc;
         }, {}) ?? {},
     };
 }
@@ -76,18 +77,15 @@ function convertToCloudfrontHeaders(headers, directResponse) {
     const cloudfrontHeaders = {};
     Object.entries(headers)
         .map(([key, value]) => [key.toLowerCase(), value])
-        .filter(([key]) => !CloudFrontBlacklistedHeaders.some((header) => typeof header === "string" ? header === key : header.test(key)) &&
+        .filter(([key]) => !cloudfrontBlacklistedHeaders.some((header) => typeof header === "string" ? header === key : header.test(key)) &&
         // Only remove read-only headers when directly responding in lambda@edge
         (directResponse ? !cloudfrontReadOnlyHeaders.includes(key) : true))
         .forEach(([key, value]) => {
         if (key === "set-cookie") {
-            const cookies = parseCookies(`${value}`);
-            if (cookies) {
-                cloudfrontHeaders[key] = cookies.map((cookie) => ({
-                    key,
-                    value: cookie,
-                }));
-            }
+            cloudfrontHeaders[key] = parseCookies(`${value}`).map((cookie) => ({
+                key,
+                value: cookie,
+            }));
             return;
         }
         cloudfrontHeaders[key] = [
@@ -104,25 +102,8 @@ async function convertToCloudFrontRequestResult(result, originalRequest) {
         const { method, clientIp, origin } = originalRequest.Records[0].cf.request;
         const responseHeaders = result.internalEvent.headers;
         // Handle external rewrite
-        if (result.isExternalRewrite) {
-            const serverResponse = createServerResponse(result.internalEvent, {});
-            await proxyRequest(result.internalEvent, serverResponse);
-            const externalResult = convertRes(serverResponse);
-            const body = await fromReadableStream(externalResult.body, externalResult.isBase64Encoded);
-            const cloudfrontResult = {
-                status: externalResult.statusCode.toString(),
-                statusDescription: "OK",
-                headers: convertToCloudfrontHeaders(externalResult.headers, true),
-                bodyEncoding: externalResult.isBase64Encoded
-                    ? "base64"
-                    : "text",
-                body,
-            };
-            debug("externalResult", cloudfrontResult);
-            return cloudfrontResult;
-        }
         let customOrigin = origin?.custom;
-        let host = responseHeaders["host"] ?? responseHeaders["Host"];
+        let host = responseHeaders.host ?? responseHeaders.Host;
         if (result.origin) {
             customOrigin = {
                 ...customOrigin,

package/dist/overrides/converters/dummy.d.ts

@@ -1,4 +1,4 @@
-import type { Converter } from "../../types/open-next";
+import type { Converter } from "../../types/overrides";
 type DummyEventOrResult = {
     type: "dummy";
     original: any;

package/dist/overrides/converters/edge.d.ts

@@ -1,5 +1,9 @@
-import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
+import type { InternalEvent, InternalResult } from "../../types/open-next";
+import type { Converter } from "../../types/overrides";
 import type { MiddlewareOutputEvent } from "../../core/routingHandler";
+declare global {
+    var __dangerous_ON_edge_converter_returns_request: boolean | undefined;
+}
 declare const converter: Converter<InternalEvent, InternalResult | ({
     type: "middleware";
 } & MiddlewareOutputEvent)>;

package/dist/overrides/converters/edge.js

@@ -5,7 +5,7 @@ const converter = {
         const searchParams = new URL(event.url).searchParams;
         const query = {};
         for (const [key, value] of searchParams.entries()) {
-            if (query[key]) {
+            if (key in query) {
                 if (Array.isArray(query[key])) {
                     query[key].push(value);
                 }
@@ -26,19 +26,17 @@ const converter = {
         const rawPath = new URL(event.url).pathname;
         const method = event.method;
         const shouldHaveBody = method !== "GET" && method !== "HEAD";
+        const cookies = Object.fromEntries(parseCookies(event.headers.get("cookie")).map((cookie) => cookie.split("=")));
         return {
             type: "core",
             method,
             rawPath,
             url: event.url,
             body: shouldHaveBody ? Buffer.from(body) : undefined,
-            headers: headers,
+            headers,
             remoteAddress: event.headers.get("x-forwarded-for") ?? "::1",
             query,
-            cookies: Object.fromEntries(parseCookies(event.headers.get("cookie") ?? "")?.map((cookie) => {
-                const [key, value] = cookie.split("=");
-                return [key, value];
-            }) ?? []),
+            cookies,
         };
     },
     convertTo: async (result) => {
@@ -52,7 +50,7 @@ const converter = {
                     url = `https://${result.internalEvent.headers.host}${url}`;
                 }
             }
-            const req = new Request(url, {
+            const request = new Request(url, {
                 body: result.internalEvent.body,
                 method: result.internalEvent.method,
                 headers: {
@@ -60,28 +58,29 @@ const converter = {
                     "x-forwarded-host": result.internalEvent.headers.host,
                 },
             });
+            if (globalThis.__dangerous_ON_edge_converter_returns_request === true) {
+                return request;
+            }
             const cfCache = (result.isISR ||
                 result.internalEvent.rawPath.startsWith("/_next/image")) &&
                 process.env.DISABLE_CACHE !== "true"
                 ? { cacheEverything: true }
                 : {};
-            return fetch(req, {
+            return fetch(request, {
                 // This is a hack to make sure that the response is cached by Cloudflare
                 // See https://developers.cloudflare.com/workers/examples/cache-using-fetch/#caching-html-resources
                 // @ts-expect-error - This is a Cloudflare specific option
                 cf: cfCache,
             });
         }
-        else {
-            const headers = new Headers();
-            for (const [key, value] of Object.entries(result.headers)) {
-                headers.set(key, Array.isArray(value) ? value.join(",") : value);
-            }
-            return new Response(result.body, {
-                status: result.statusCode,
-                headers: headers,
-            });
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(result.headers)) {
+            headers.set(key, Array.isArray(value) ? value.join(",") : value);
         }
+        return new Response(result.body, {
+            status: result.statusCode,
+            headers: headers,
+        });
     },
     name: "edge",
 };

package/dist/overrides/converters/node.d.ts

@@ -1,3 +1,3 @@
-import type { Converter } from "../../types/open-next";
+import type { Converter } from "../../types/overrides";
 declare const converter: Converter;
 export default converter;

package/dist/overrides/converters/node.js

@@ -28,7 +28,7 @@ const converter = {
                 req.socket.remoteAddress ??
                 "::1",
             query,
-            cookies: Object.fromEntries(parseCookies(req.headers["cookie"])?.map((cookie) => {
+            cookies: Object.fromEntries(parseCookies(req.headers.cookie)?.map((cookie) => {
                 const [key, value] = cookie.split("=");
                 return [key, value];
             }) ?? []),

package/dist/overrides/converters/sqs-revalidate.d.ts

@@ -1,4 +1,4 @@
-import type { Converter } from "../../types/open-next";
+import type { Converter } from "../../types/overrides";
 import type { RevalidateEvent } from "../../adapters/revalidate";
 declare const converter: Converter<RevalidateEvent, RevalidateEvent>;
 export default converter;

package/dist/overrides/imageLoader/dummy.d.ts

@@ -1,3 +1,3 @@
-import type { ImageLoader } from "../../types/open-next";
+import type { ImageLoader } from "../../types/overrides";
 declare const dummyLoader: ImageLoader;
 export default dummyLoader;

package/dist/overrides/imageLoader/host.d.ts

@@ -1,3 +1,3 @@
-import type { ImageLoader } from "../../types/open-next";
+import type { ImageLoader } from "../../types/overrides";
 declare const hostLoader: ImageLoader;
 export default hostLoader;

package/dist/overrides/imageLoader/s3.d.ts

@@ -1,3 +1,3 @@
-import type { ImageLoader } from "../../types/open-next";
+import type { ImageLoader } from "../../types/overrides";
 declare const s3Loader: ImageLoader;
 export default s3Loader;

package/dist/overrides/imageLoader/s3.js

@@ -16,7 +16,7 @@ const s3Loader = {
         const response = await s3Client.send(new GetObjectCommand({
             Bucket: BUCKET_NAME,
             Key: keyPrefix
-                ? keyPrefix + "/" + key.replace(/^\//, "")
+                ? `${keyPrefix}/${key.replace(/^\//, "")}`
                 : key.replace(/^\//, ""),
         }));
         const body = response.Body;

package/dist/overrides/incrementalCache/dummy.d.ts

@@ -1,3 +1,3 @@
-import type { IncrementalCache } from "./types";
+import type { IncrementalCache } from "../../types/overrides";
 declare const dummyIncrementalCache: IncrementalCache;
 export default dummyIncrementalCache;

package/dist/overrides/incrementalCache/s3-lite.d.ts

@@ -1,3 +1,3 @@
-import type { IncrementalCache } from "./types";
+import type { IncrementalCache } from "../../types/overrides";
 declare const incrementalCache: IncrementalCache;
 export default incrementalCache;

package/dist/overrides/incrementalCache/s3-lite.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import path from "node:path";
 import { AwsClient } from "aws4fetch";
-import path from "path";
 import { IgnorableError, RecoverableError } from "../../utils/error";
 import { customFetchClient } from "../../utils/fetch";
 import { parseNumberFromEnv } from "../../adapters/util";
@@ -10,16 +10,14 @@ const getAwsClient = () => {
     if (awsClient) {
         return awsClient;
     }
-    else {
-        awsClient = new AwsClient({
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            sessionToken: process.env.AWS_SESSION_TOKEN,
-            region: CACHE_BUCKET_REGION,
-            retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
-        });
-        return awsClient;
-    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: CACHE_BUCKET_REGION,
+        retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+    });
+    return awsClient;
 };
 const awsFetch = async (key, options) => {
     const { CACHE_BUCKET_REGION, CACHE_BUCKET_NAME } = process.env;
@@ -39,16 +37,14 @@ const incrementalCache = {
         if (result.status === 404) {
             throw new IgnorableError("Not found");
         }
-        else if (result.status !== 200) {
+        if (result.status !== 200) {
             throw new RecoverableError(`Failed to get cache: ${result.status}`);
         }
-        else {
-            const cacheData = await result.json();
-            return {
-                value: cacheData,
-                lastModified: new Date(result.headers.get("last-modified") ?? "").getTime(),
-            };
-        }
+        const cacheData = await result.json();
+        return {
+            value: cacheData,
+            lastModified: new Date(result.headers.get("last-modified") ?? "").getTime(),
+        };
     },
     async set(key, value, isFetch) {
         const response = await awsFetch(buildS3Key(key, isFetch ? "fetch" : "cache"), {

package/dist/overrides/incrementalCache/s3.d.ts

@@ -1,3 +1,3 @@
-import type { IncrementalCache } from "./types";
+import type { IncrementalCache } from "../../types/overrides";
 declare const incrementalCache: IncrementalCache;
 export default incrementalCache;

package/dist/overrides/incrementalCache/s3.js

@@ -1,5 +1,5 @@
+import path from "node:path";
 import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
-import path from "path";
 import { awsLogger } from "../../adapters/logger";
 import { parseNumberFromEnv } from "../../adapters/util";
 const { CACHE_BUCKET_REGION, CACHE_BUCKET_KEY_PREFIX, NEXT_BUILD_ID, CACHE_BUCKET_NAME, } = process.env;

package/dist/overrides/originResolver/dummy.d.ts

@@ -1,3 +1,3 @@
-import type { OriginResolver } from "../../types/open-next";
+import type { OriginResolver } from "../../types/overrides";
 declare const dummyOriginResolver: OriginResolver;
 export default dummyOriginResolver;

package/dist/overrides/originResolver/pattern-env.d.ts

@@ -1,3 +1,3 @@
-import type { OriginResolver } from "../../types/open-next";
+import type { OriginResolver } from "../../types/overrides";
 declare const envLoader: OriginResolver;
 export default envLoader;

package/dist/overrides/originResolver/pattern-env.js

@@ -9,24 +9,23 @@ const envLoader = {
                     // Convert cloudfront pattern to regex
                     return new RegExp(
                     // transform glob pattern to regex
-                    "/" +
-                        pattern
-                            .replace(/\*\*/g, "(.*)")
-                            .replace(/\*/g, "([^/]*)")
-                            .replace(/\//g, "\\/")
-                            .replace(/\?/g, ".")).test(_path);
+                    `/${pattern
+                        .replace(/\*\*/g, "(.*)")
+                        .replace(/\*/g, "([^/]*)")
+                        .replace(/\//g, "\\/")
+                        .replace(/\?/g, ".")}`).test(_path);
                 })) {
                     debug("Using origin", key, value.patterns);
                     return origin[key];
                 }
             }
-            if (_path.startsWith("/_next/image") && origin["imageOptimizer"]) {
+            if (_path.startsWith("/_next/image") && origin.imageOptimizer) {
                 debug("Using origin", "imageOptimizer", _path);
-                return origin["imageOptimizer"];
+                return origin.imageOptimizer;
             }
-            if (origin["default"]) {
-                debug("Using default origin", origin["default"], _path);
-                return origin["default"];
+            if (origin.default) {
+                debug("Using default origin", origin.default, _path);
+                return origin.default;
             }
             return false;
         }

package/dist/overrides/proxyExternalRequest/dummy.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyExternalRequest } from "../../types/overrides";
+declare const DummyProxyExternalRequest: ProxyExternalRequest;
+export default DummyProxyExternalRequest;

package/dist/overrides/proxyExternalRequest/dummy.js

@@ -0,0 +1,7 @@
+const DummyProxyExternalRequest = {
+    name: "dummy",
+    proxy: async (_event) => {
+        throw new Error("This is a dummy implementation");
+    },
+};
+export default DummyProxyExternalRequest;

package/dist/overrides/proxyExternalRequest/fetch.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyExternalRequest } from "../../types/overrides";
+declare const fetchProxy: ProxyExternalRequest;
+export default fetchProxy;

package/dist/overrides/proxyExternalRequest/fetch.js

@@ -0,0 +1,25 @@
+import { emptyReadableStream } from "../../utils/stream";
+const fetchProxy = {
+    name: "fetch-proxy",
+    // @ts-ignore
+    proxy: async (internalEvent) => {
+        const { url, headers, method, body } = internalEvent;
+        const response = await fetch(url, {
+            method,
+            headers,
+            body,
+        });
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+        return {
+            type: "core",
+            headers: responseHeaders,
+            statusCode: response.status,
+            isBase64Encoded: true,
+            body: response.body ?? emptyReadableStream(),
+        };
+    },
+};
+export default fetchProxy;

package/dist/overrides/proxyExternalRequest/node.d.ts

@@ -0,0 +1,3 @@
+import type { ProxyExternalRequest } from "../../types/overrides";
+declare const nodeProxy: ProxyExternalRequest;
+export default nodeProxy;

package/dist/overrides/proxyExternalRequest/node.js

@@ -0,0 +1,67 @@
+import { debug, error } from "node:console";
+import { request } from "node:https";
+import { Readable } from "node:stream";
+import { isBinaryContentType } from "../../adapters/binary";
+function filterHeadersForProxy(headers) {
+    const filteredHeaders = {};
+    const disallowedHeaders = [
+        "host",
+        "connection",
+        "via",
+        "x-cache",
+        "transfer-encoding",
+        "content-encoding",
+        "content-length",
+    ];
+    Object.entries(headers)
+        .filter(([key, _]) => {
+        const lowerKey = key.toLowerCase();
+        return !(disallowedHeaders.includes(lowerKey) || lowerKey.startsWith("x-amz"));
+    })
+        .forEach(([key, value]) => {
+        filteredHeaders[key] = value?.toString() ?? "";
+    });
+    return filteredHeaders;
+}
+const nodeProxy = {
+    name: "node-proxy",
+    proxy: (internalEvent) => {
+        const { url, headers, method, body } = internalEvent;
+        debug("proxyRequest", url);
+        return new Promise((resolve, reject) => {
+            const filteredHeaders = filterHeadersForProxy(headers);
+            debug("filteredHeaders", filteredHeaders);
+            const req = request(url, {
+                headers: filteredHeaders,
+                method,
+                rejectUnauthorized: false,
+            }, (_res) => {
+                const nodeReadableStream = _res.headers["content-encoding"] === "br"
+                    ? _res.pipe(require("node:zlib").createBrotliDecompress())
+                    : _res.headers["content-encoding"] === "gzip"
+                        ? _res.pipe(require("node:zlib").createGunzip())
+                        : _res;
+                const isBase64Encoded = isBinaryContentType(headers["content-type"]) ||
+                    !!headers["content-encoding"];
+                const result = {
+                    type: "core",
+                    headers: filterHeadersForProxy(_res.headers),
+                    statusCode: _res.statusCode ?? 200,
+                    // TODO: check base64 encoding
+                    isBase64Encoded,
+                    body: Readable.toWeb(nodeReadableStream),
+                };
+                resolve(result);
+                _res.on("error", (e) => {
+                    error("proxyRequest error", e);
+                    reject(e);
+                });
+            });
+            if (body && method !== "GET" && method !== "HEAD") {
+                req.write(body);
+            }
+            req.end();
+        });
+    },
+};
+export default nodeProxy;

package/dist/overrides/queue/dummy.d.ts

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const dummyQueue: Queue;
 export default dummyQueue;

package/dist/overrides/queue/sqs-lite.d.ts

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const queue: Queue;
 export default queue;

package/dist/overrides/queue/sqs-lite.js

@@ -7,15 +7,13 @@ const getAwsClient = () => {
     if (awsClient) {
         return awsClient;
     }
-    else {
-        awsClient = new AwsClient({
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            sessionToken: process.env.AWS_SESSION_TOKEN,
-            region: process.env.REVALIDATION_QUEUE_REGION,
-        });
-        return awsClient;
-    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: process.env.REVALIDATION_QUEUE_REGION,
+    });
+    return awsClient;
 };
 const awsFetch = (body) => {
     const { REVALIDATION_QUEUE_REGION } = process.env;

package/dist/overrides/queue/sqs.d.ts

@@ -1,3 +1,3 @@
-import type { Queue } from "./types";
+import type { Queue } from "../../types/overrides";
 declare const queue: Queue;
 export default queue;

package/dist/overrides/queue/sqs.js

@@ -1,4 +1,4 @@
-import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
 import { awsLogger } from "../../adapters/logger";
 // Expected environment variables
 const { REVALIDATION_QUEUE_REGION, REVALIDATION_QUEUE_URL } = process.env;

package/dist/overrides/tagCache/constants.js

@@ -7,10 +7,10 @@ const DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY = 4;
 export const getDynamoBatchWriteCommandConcurrency = () => {
     const dynamoBatchWriteCommandConcurrencyFromEnv = process.env.DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;
     const parsedDynamoBatchWriteCommandConcurrencyFromEnv = dynamoBatchWriteCommandConcurrencyFromEnv
-        ? parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
+        ? Number.parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
         : undefined;
     if (parsedDynamoBatchWriteCommandConcurrencyFromEnv &&
-        !isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
+        !Number.isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
         return parsedDynamoBatchWriteCommandConcurrencyFromEnv;
     }
     return DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;

package/dist/overrides/tagCache/dummy.d.ts

@@ -1,3 +1,3 @@
-import type { TagCache } from "./types";
+import type { TagCache } from "../../types/overrides";
 declare const dummyTagCache: TagCache;
 export default dummyTagCache;

package/dist/overrides/tagCache/dynamodb-lite.d.ts

@@ -1,3 +1,3 @@
-import type { TagCache } from "./types";
+import type { TagCache } from "../../types/overrides";
 declare const tagCache: TagCache;
 export default tagCache;