@depup/payload 3.79.1-depup.0

package/dist/utilities/createLocalReq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLocalReq.d.ts","sourceRoot":"","sources":["../../src/utilities/createLocalReq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAsFvD,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,CAAA;IACpC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB,CAAA;AAED,KAAK,cAAc,GAAG,CAAC,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;AAEnG,eAAO,MAAM,cAAc,EAAE,cA+D5B,CAAA"}

package/dist/utilities/createLocalReq.js

@@ -0,0 +1,110 @@
+import { getDataLoader } from '../collections/dataloader.js';
+import { getLocalI18n } from '../translations/getLocalI18n.js';
+import { sanitizeFallbackLocale } from '../utilities/sanitizeFallbackLocale.js';
+function getRequestContext(req = {
+    context: null
+}, context = {}) {
+    if (req.context) {
+        if (Object.keys(req.context).length === 0 && req.context.constructor === Object) {
+            // if req.context is `{}` avoid unnecessary spread
+            return context;
+        } else {
+            return {
+                ...req.context,
+                ...context
+            };
+        }
+    } else {
+        return context;
+    }
+}
+const attachFakeURLProperties = (req, urlSuffix)=>{
+    /**
+   * *NOTE*
+   * If no URL is provided, the local API was called outside
+   * the context of a request. Therefore we create a fake URL object.
+   * `ts-expect-error` is used below for properties that are 'read-only'.
+   * Since they do not exist yet we can safely ignore the error.
+   */ let urlObject;
+    function getURLObject() {
+        if (urlObject) {
+            return urlObject;
+        }
+        const fallbackURL = `http://${req.host || 'localhost'}${urlSuffix || ''}`;
+        const urlToUse = req?.url || (req.payload?.config?.serverURL ? `${req.payload?.config.serverURL}${urlSuffix || ''}` : fallbackURL);
+        try {
+            urlObject = new URL(urlToUse);
+        } catch (_err) {
+            req.payload?.logger.error(`Failed to create URL object from URL: ${urlToUse}, falling back to ${fallbackURL}`);
+            urlObject = new URL(fallbackURL);
+        }
+        return urlObject;
+    }
+    if (!req.host) {
+        req.host = getURLObject().host;
+    }
+    if (!req.protocol) {
+        req.protocol = getURLObject().protocol;
+    }
+    if (!req.pathname) {
+        req.pathname = getURLObject().pathname;
+    }
+    if (!req.searchParams) {
+        // @ts-expect-error eslint-disable-next-line no-param-reassign
+        req.searchParams = getURLObject().searchParams;
+    }
+    if (!req.origin) {
+        // @ts-expect-error eslint-disable-next-line no-param-reassign
+        req.origin = getURLObject().origin;
+    }
+    if (!req?.url) {
+        // @ts-expect-error eslint-disable-next-line no-param-reassign
+        req.url = getURLObject().href;
+    }
+};
+export const createLocalReq = async ({ context, depth, fallbackLocale, locale: localeArg, req = {}, urlSuffix, user }, payload)=>{
+    const localization = payload.config?.localization;
+    if (localization) {
+        const locale = localeArg === '*' ? 'all' : localeArg;
+        const defaultLocale = localization.defaultLocale;
+        const localeCandidate = locale || req?.locale || req?.query?.locale;
+        req.locale = localeCandidate && typeof localeCandidate === 'string' ? localeCandidate : defaultLocale;
+        const sanitizedFallback = sanitizeFallbackLocale({
+            fallbackLocale: fallbackLocale,
+            locale: req.locale,
+            localization
+        });
+        req.fallbackLocale = sanitizedFallback;
+    }
+    const i18n = req?.i18n || await getLocalI18n({
+        config: payload.config,
+        language: payload.config.i18n.fallbackLanguage
+    });
+    if (!req.headers) {
+        req.headers = new Headers();
+    }
+    req.context = getRequestContext(req, context);
+    req.payloadAPI = req?.payloadAPI || 'local';
+    req.payload = payload;
+    req.i18n = i18n;
+    req.t = i18n.t;
+    req.user = user || req?.user || null;
+    // Ensure user.collection is set for auth-related access control
+    // TODO (4.0): Instead of silently falling back, throw an error if user.collection is missing
+    if (req.user && !req.user.collection) {
+        req.user = {
+            ...req.user,
+            collection: payload.config.admin.user
+        };
+    }
+    req.payloadDataLoader = req?.payloadDataLoader || getDataLoader(req);
+    req.routeParams = req?.routeParams || {};
+    req.query = req?.query || {};
+    if (typeof depth !== 'undefined') {
+        req.query.depth = depth;
+    }
+    attachFakeURLProperties(req, urlSuffix);
+    return req;
+};
+
+//# sourceMappingURL=createLocalReq.js.map

package/dist/utilities/createLocalReq.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createLocalReq.ts"],"sourcesContent":["import type { Payload, RequestContext, TypedLocale, TypedUser } from '../index.js'\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { getDataLoader } from '../collections/dataloader.js'\nimport { getLocalI18n } from '../translations/getLocalI18n.js'\nimport { sanitizeFallbackLocale } from '../utilities/sanitizeFallbackLocale.js'\n\nfunction getRequestContext(\n  req: Partial<PayloadRequest> = { context: null } as unknown as PayloadRequest,\n  context: RequestContext = {},\n): RequestContext {\n  if (req.context) {\n    if (Object.keys(req.context).length === 0 && req.context.constructor === Object) {\n      // if req.context is `{}` avoid unnecessary spread\n      return context\n    } else {\n      return { ...req.context, ...context }\n    }\n  } else {\n    return context\n  }\n}\n\nconst attachFakeURLProperties = (req: Partial<PayloadRequest>, urlSuffix?: string) => {\n  /**\n   * *NOTE*\n   * If no URL is provided, the local API was called outside\n   * the context of a request. Therefore we create a fake URL object.\n   * `ts-expect-error` is used below for properties that are 'read-only'.\n   * Since they do not exist yet we can safely ignore the error.\n   */\n  let urlObject: undefined | URL\n\n  function getURLObject() {\n    if (urlObject) {\n      return urlObject\n    }\n\n    const fallbackURL = `http://${req.host || 'localhost'}${urlSuffix || ''}`\n\n    const urlToUse =\n      req?.url ||\n      (req.payload?.config?.serverURL\n        ? `${req.payload?.config.serverURL}${urlSuffix || ''}`\n        : fallbackURL)\n\n    try {\n      urlObject = new URL(urlToUse)\n    } catch (_err) {\n      req.payload?.logger.error(\n        `Failed to create URL object from URL: ${urlToUse}, falling back to ${fallbackURL}`,\n      )\n\n      urlObject = new URL(fallbackURL)\n    }\n\n    return urlObject\n  }\n\n  if (!req.host) {\n    req.host = getURLObject().host\n  }\n\n  if (!req.protocol) {\n    req.protocol = getURLObject().protocol\n  }\n\n  if (!req.pathname) {\n    req.pathname = getURLObject().pathname\n  }\n\n  if (!req.searchParams) {\n    // @ts-expect-error eslint-disable-next-line no-param-reassign\n    req.searchParams = getURLObject().searchParams\n  }\n\n  if (!req.origin) {\n    // @ts-expect-error eslint-disable-next-line no-param-reassign\n    req.origin = getURLObject().origin\n  }\n\n  if (!req?.url) {\n    // @ts-expect-error eslint-disable-next-line no-param-reassign\n    req.url = getURLObject().href\n  }\n}\n\nexport type CreateLocalReqOptions = {\n  context?: RequestContext\n  depth?: number\n  fallbackLocale?: false | TypedLocale\n  locale?: string\n  req?: Partial<PayloadRequest>\n  urlSuffix?: string\n  user?: TypedUser\n}\n\ntype CreateLocalReq = (options: CreateLocalReqOptions, payload: Payload) => Promise<PayloadRequest>\n\nexport const createLocalReq: CreateLocalReq = async (\n  {\n    context,\n    depth,\n    fallbackLocale,\n    locale: localeArg,\n    req = {} as PayloadRequest,\n    urlSuffix,\n    user,\n  },\n  payload,\n): Promise<PayloadRequest> => {\n  const localization = payload.config?.localization\n\n  if (localization) {\n    const locale = localeArg === '*' ? 'all' : localeArg\n    const defaultLocale = localization.defaultLocale\n    const localeCandidate = locale || req?.locale || req?.query?.locale\n\n    req.locale =\n      localeCandidate && typeof localeCandidate === 'string' ? localeCandidate : defaultLocale\n\n    const sanitizedFallback = sanitizeFallbackLocale({\n      fallbackLocale: fallbackLocale!,\n      locale: req.locale,\n      localization,\n    })\n\n    req.fallbackLocale = sanitizedFallback!\n  }\n\n  const i18n =\n    req?.i18n ||\n    (await getLocalI18n({ config: payload.config, language: payload.config.i18n.fallbackLanguage }))\n\n  if (!req.headers) {\n    req.headers = new Headers()\n  }\n\n  req.context = getRequestContext(req, context)\n  req.payloadAPI = req?.payloadAPI || 'local'\n  req.payload = payload\n  req.i18n = i18n\n  req.t = i18n.t\n  req.user = user || req?.user || null\n\n  // Ensure user.collection is set for auth-related access control\n  // TODO (4.0): Instead of silently falling back, throw an error if user.collection is missing\n  if (req.user && !req.user.collection) {\n    req.user = { ...req.user, collection: payload.config.admin.user }\n  }\n\n  req.payloadDataLoader = req?.payloadDataLoader || getDataLoader(req as PayloadRequest)\n  req.routeParams = req?.routeParams || {}\n  req.query = req?.query || {}\n\n  if (typeof depth !== 'undefined') {\n    req.query.depth = depth\n  }\n\n  attachFakeURLProperties(req, urlSuffix)\n\n  return req as PayloadRequest\n}\n"],"names":["getDataLoader","getLocalI18n","sanitizeFallbackLocale","getRequestContext","req","context","Object","keys","length","attachFakeURLProperties","urlSuffix","urlObject","getURLObject","fallbackURL","host","urlToUse","url","payload","config","serverURL","URL","_err","logger","error","protocol","pathname","searchParams","origin","href","createLocalReq","depth","fallbackLocale","locale","localeArg","user","localization","defaultLocale","localeCandidate","query","sanitizedFallback","i18n","language","fallbackLanguage","headers","Headers","payloadAPI","t","collection","admin","payloadDataLoader","routeParams"],"mappings":"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"}

package/dist/utilities/createLocalReq.spec.js

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createLocalReq } from './createLocalReq.js';
+describe('createLocalReq - URL construction', ()=>{
+    const mockPayload = {
+        config: {
+            serverURL: undefined,
+            i18n: {
+                fallbackLanguage: 'en',
+                supportedLanguages: {
+                    en: {}
+                },
+                translations: {}
+            },
+            localization: undefined
+        },
+        logger: {
+            error: vi.fn()
+        }
+    };
+    it('should use req.url when provided and serverURL is undefined', async ()=>{
+        const req = {
+            url: 'http://example.com/api/test'
+        };
+        const result = await createLocalReq({
+            req
+        }, mockPayload);
+        expect(result.url).toBe('http://example.com/api/test');
+        expect(mockPayload.logger.error).not.toHaveBeenCalled();
+    });
+    it('should use serverURL when req.url is not provided', async ()=>{
+        const payloadWithServerURL = {
+            config: {
+                serverURL: 'http://configured-server.com',
+                i18n: {
+                    fallbackLanguage: 'en',
+                    supportedLanguages: {
+                        en: {}
+                    },
+                    translations: {}
+                },
+                localization: undefined
+            },
+            logger: {
+                error: vi.fn()
+            }
+        };
+        const req = {};
+        const result = await createLocalReq({
+            req,
+            urlSuffix: '/api'
+        }, payloadWithServerURL);
+        expect(result.url).toContain('http://configured-server.com/api');
+        expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled();
+    });
+    it('should prioritize req.url over serverURL', async ()=>{
+        const payloadWithServerURL = {
+            config: {
+                serverURL: 'http://configured-server.com',
+                i18n: {
+                    fallbackLanguage: 'en',
+                    supportedLanguages: {
+                        en: {}
+                    },
+                    translations: {}
+                },
+                localization: undefined
+            },
+            logger: {
+                error: vi.fn()
+            }
+        };
+        const req = {
+            url: 'http://actual-request.com/api/test'
+        };
+        const result = await createLocalReq({
+            req
+        }, payloadWithServerURL);
+        expect(result.url).toBe('http://actual-request.com/api/test');
+        expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled();
+    });
+    it('should fall back to localhost when neither req.url nor serverURL provided', async ()=>{
+        const req = {};
+        const result = await createLocalReq({
+            req
+        }, mockPayload);
+        expect(result.url).toBe('http://localhost/');
+        expect(mockPayload.logger.error).not.toHaveBeenCalled();
+    });
+    it('should append urlSuffix to serverURL when used', async ()=>{
+        const payloadWithServerURL = {
+            config: {
+                serverURL: 'http://configured-server.com',
+                i18n: {
+                    fallbackLanguage: 'en',
+                    supportedLanguages: {
+                        en: {}
+                    },
+                    translations: {}
+                },
+                localization: undefined
+            },
+            logger: {
+                error: vi.fn()
+            }
+        };
+        const req = {};
+        const result = await createLocalReq({
+            req,
+            urlSuffix: '/api/preview'
+        }, payloadWithServerURL);
+        expect(result.url).toContain('/api/preview');
+        expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled();
+    });
+    it('should append urlSuffix to fallback URL when neither req.url nor serverURL provided', async ()=>{
+        const req = {};
+        const result = await createLocalReq({
+            req,
+            urlSuffix: '/api/test'
+        }, mockPayload);
+        expect(result.url).toBe('http://localhost/api/test');
+        expect(mockPayload.logger.error).not.toHaveBeenCalled();
+    });
+});
+
+//# sourceMappingURL=createLocalReq.spec.js.map

package/dist/utilities/createLocalReq.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createLocalReq.spec.ts"],"sourcesContent":["import { describe, expect, it, vi } from 'vitest'\n\nimport type { Payload } from '../index.js'\n\nimport { createLocalReq } from './createLocalReq.js'\n\ndescribe('createLocalReq - URL construction', () => {\n  const mockPayload = {\n    config: {\n      serverURL: undefined,\n      i18n: {\n        fallbackLanguage: 'en',\n        supportedLanguages: { en: {} },\n        translations: {},\n      },\n      localization: undefined,\n    },\n    logger: {\n      error: vi.fn(),\n    },\n  } as unknown as Payload\n\n  it('should use req.url when provided and serverURL is undefined', async () => {\n    const req = {\n      url: 'http://example.com/api/test',\n    }\n\n    const result = await createLocalReq({ req }, mockPayload)\n\n    expect(result.url).toBe('http://example.com/api/test')\n    expect(mockPayload.logger.error).not.toHaveBeenCalled()\n  })\n\n  it('should use serverURL when req.url is not provided', async () => {\n    const payloadWithServerURL = {\n      config: {\n        serverURL: 'http://configured-server.com',\n        i18n: {\n          fallbackLanguage: 'en',\n          supportedLanguages: { en: {} },\n          translations: {},\n        },\n        localization: undefined,\n      },\n      logger: {\n        error: vi.fn(),\n      },\n    } as unknown as Payload\n\n    const req = {}\n\n    const result = await createLocalReq({ req, urlSuffix: '/api' }, payloadWithServerURL)\n\n    expect(result.url).toContain('http://configured-server.com/api')\n    expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled()\n  })\n\n  it('should prioritize req.url over serverURL', async () => {\n    const payloadWithServerURL = {\n      config: {\n        serverURL: 'http://configured-server.com',\n        i18n: {\n          fallbackLanguage: 'en',\n          supportedLanguages: { en: {} },\n          translations: {},\n        },\n        localization: undefined,\n      },\n      logger: {\n        error: vi.fn(),\n      },\n    } as unknown as Payload\n\n    const req = {\n      url: 'http://actual-request.com/api/test',\n    }\n\n    const result = await createLocalReq({ req }, payloadWithServerURL)\n\n    expect(result.url).toBe('http://actual-request.com/api/test')\n    expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled()\n  })\n\n  it('should fall back to localhost when neither req.url nor serverURL provided', async () => {\n    const req = {}\n\n    const result = await createLocalReq({ req }, mockPayload)\n\n    expect(result.url).toBe('http://localhost/')\n    expect(mockPayload.logger.error).not.toHaveBeenCalled()\n  })\n\n  it('should append urlSuffix to serverURL when used', async () => {\n    const payloadWithServerURL = {\n      config: {\n        serverURL: 'http://configured-server.com',\n        i18n: {\n          fallbackLanguage: 'en',\n          supportedLanguages: { en: {} },\n          translations: {},\n        },\n        localization: undefined,\n      },\n      logger: {\n        error: vi.fn(),\n      },\n    } as unknown as Payload\n\n    const req = {}\n\n    const result = await createLocalReq({ req, urlSuffix: '/api/preview' }, payloadWithServerURL)\n\n    expect(result.url).toContain('/api/preview')\n    expect(payloadWithServerURL.logger.error).not.toHaveBeenCalled()\n  })\n\n  it('should append urlSuffix to fallback URL when neither req.url nor serverURL provided', async () => {\n    const req = {}\n\n    const result = await createLocalReq({ req, urlSuffix: '/api/test' }, mockPayload)\n\n    expect(result.url).toBe('http://localhost/api/test')\n    expect(mockPayload.logger.error).not.toHaveBeenCalled()\n  })\n})\n"],"names":["describe","expect","it","vi","createLocalReq","mockPayload","config","serverURL","undefined","i18n","fallbackLanguage","supportedLanguages","en","translations","localization","logger","error","fn","req","url","result","toBe","not","toHaveBeenCalled","payloadWithServerURL","urlSuffix","toContain"],"mappings":"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"}

package/dist/utilities/createPayloadRequest.d.ts

@@ -0,0 +1,14 @@
+import type { SanitizedConfig } from '../config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+type Args = {
+    canSetHeaders?: boolean;
+    config: Promise<SanitizedConfig> | SanitizedConfig;
+    params?: {
+        collection: string;
+    };
+    payloadInstanceCacheKey?: string;
+    request: Request;
+};
+export declare const createPayloadRequest: ({ canSetHeaders, config: configPromise, params, payloadInstanceCacheKey, request, }: Args) => Promise<PayloadRequest>;
+export {};
+//# sourceMappingURL=createPayloadRequest.d.ts.map

package/dist/utilities/createPayloadRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPayloadRequest.d.ts","sourceRoot":"","sources":["../../src/utilities/createPayloadRequest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEzD,OAAO,KAAK,EAAkC,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAUvF,KAAK,IAAI,GAAG;IACV,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,MAAM,CAAC,EAAE;QACP,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,oBAAoB,wFAM9B,IAAI,KAAG,OAAO,CAAC,cAAc,CA0G/B,CAAA"}

package/dist/utilities/createPayloadRequest.js

@@ -0,0 +1,92 @@
+import { initI18n } from '@payloadcms/translations';
+import * as qs from 'qs-esm';
+import { executeAuthStrategies } from '../auth/executeAuthStrategies.js';
+import { getDataLoader } from '../collections/dataloader.js';
+import { getPayload } from '../index.js';
+import { sanitizeLocales } from './addLocalesToRequest.js';
+import { formatAdminURL } from './formatAdminURL.js';
+import { getRequestLanguage } from './getRequestLanguage.js';
+import { parseCookies } from './parseCookies.js';
+export const createPayloadRequest = async ({ canSetHeaders, config: configPromise, params, payloadInstanceCacheKey, request })=>{
+    const cookies = parseCookies(request.headers);
+    const payload = await getPayload({
+        config: configPromise,
+        cron: true,
+        key: payloadInstanceCacheKey
+    });
+    const { config } = payload;
+    const localization = config.localization;
+    const urlProperties = new URL(request.url);
+    const { pathname, searchParams } = urlProperties;
+    const isGraphQL = !config.graphQL.disable && pathname === formatAdminURL({
+        apiRoute: config.routes.api,
+        path: config.routes.graphQL
+    });
+    const language = getRequestLanguage({
+        config,
+        cookies,
+        headers: request.headers
+    });
+    const i18n = await initI18n({
+        config: config.i18n,
+        context: 'api',
+        language
+    });
+    let locale = searchParams.get('locale');
+    const { search: queryToParse } = urlProperties;
+    const query = queryToParse ? qs.parse(queryToParse, {
+        arrayLimit: 1000,
+        depth: 10,
+        ignoreQueryPrefix: true
+    }) : {};
+    const fallbackFromRequest = query.fallbackLocale || searchParams.get('fallback-locale') || searchParams.get('fallbackLocale');
+    let fallbackLocale = fallbackFromRequest;
+    if (localization) {
+        const locales = sanitizeLocales({
+            fallbackLocale: fallbackLocale,
+            locale: locale,
+            localization
+        });
+        fallbackLocale = locales.fallbackLocale;
+        locale = locales.locale;
+    }
+    const customRequest = {
+        context: {},
+        fallbackLocale: fallbackLocale,
+        hash: urlProperties.hash,
+        host: urlProperties.host,
+        href: urlProperties.href,
+        i18n,
+        locale,
+        origin: urlProperties.origin,
+        pathname: urlProperties.pathname,
+        payload,
+        payloadAPI: isGraphQL ? 'GraphQL' : 'REST',
+        payloadDataLoader: undefined,
+        payloadUploadSizes: {},
+        port: urlProperties.port,
+        protocol: urlProperties.protocol,
+        query,
+        routeParams: params || {},
+        search: urlProperties.search,
+        searchParams: urlProperties.searchParams,
+        t: i18n.t,
+        transactionID: undefined,
+        user: null
+    };
+    const req = Object.assign(request, customRequest);
+    req.payloadDataLoader = getDataLoader(req);
+    const { responseHeaders, user } = await executeAuthStrategies({
+        canSetHeaders,
+        headers: req.headers,
+        isGraphQL,
+        payload
+    });
+    req.user = user;
+    if (responseHeaders) {
+        req.responseHeaders = responseHeaders;
+    }
+    return req;
+};
+
+//# sourceMappingURL=createPayloadRequest.js.map

package/dist/utilities/createPayloadRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createPayloadRequest.ts"],"sourcesContent":["import { initI18n } from '@payloadcms/translations'\nimport * as qs from 'qs-esm'\n\nimport type { SanitizedConfig } from '../config/types.js'\nimport type { TypedFallbackLocale } from '../index.js'\nimport type { CustomPayloadRequestProperties, PayloadRequest } from '../types/index.js'\n\nimport { executeAuthStrategies } from '../auth/executeAuthStrategies.js'\nimport { getDataLoader } from '../collections/dataloader.js'\nimport { getPayload } from '../index.js'\nimport { sanitizeLocales } from './addLocalesToRequest.js'\nimport { formatAdminURL } from './formatAdminURL.js'\nimport { getRequestLanguage } from './getRequestLanguage.js'\nimport { parseCookies } from './parseCookies.js'\n\ntype Args = {\n  canSetHeaders?: boolean\n  config: Promise<SanitizedConfig> | SanitizedConfig\n  params?: {\n    collection: string\n  }\n  payloadInstanceCacheKey?: string\n  request: Request\n}\n\nexport const createPayloadRequest = async ({\n  canSetHeaders,\n  config: configPromise,\n  params,\n  payloadInstanceCacheKey,\n  request,\n}: Args): Promise<PayloadRequest> => {\n  const cookies = parseCookies(request.headers)\n  const payload = await getPayload({\n    config: configPromise,\n    cron: true,\n    key: payloadInstanceCacheKey,\n  })\n\n  const { config } = payload\n  const localization = config.localization\n\n  const urlProperties = new URL(request.url)\n  const { pathname, searchParams } = urlProperties\n\n  const isGraphQL =\n    !config.graphQL.disable &&\n    pathname ===\n      formatAdminURL({\n        apiRoute: config.routes.api,\n        path: config.routes.graphQL as `/${string}`,\n      })\n\n  const language = getRequestLanguage({\n    config,\n    cookies,\n    headers: request.headers,\n  })\n\n  const i18n = await initI18n({\n    config: config.i18n,\n    context: 'api',\n    language,\n  })\n\n  let locale = searchParams.get('locale')\n\n  const { search: queryToParse } = urlProperties\n\n  const query = queryToParse\n    ? qs.parse(queryToParse, {\n        arrayLimit: 1000,\n        depth: 10,\n        ignoreQueryPrefix: true,\n      })\n    : {}\n\n  const fallbackFromRequest = (query.fallbackLocale ||\n    searchParams.get('fallback-locale') ||\n    searchParams.get('fallbackLocale')) as TypedFallbackLocale\n\n  let fallbackLocale = fallbackFromRequest\n\n  if (localization) {\n    const locales = sanitizeLocales({\n      fallbackLocale: fallbackLocale!,\n      locale: locale!,\n      localization,\n    })\n\n    fallbackLocale = locales.fallbackLocale!\n    locale = locales.locale!\n  }\n\n  const customRequest: CustomPayloadRequestProperties = {\n    context: {},\n    fallbackLocale: fallbackLocale!,\n    hash: urlProperties.hash,\n    host: urlProperties.host,\n    href: urlProperties.href,\n    i18n,\n    locale,\n    origin: urlProperties.origin,\n    pathname: urlProperties.pathname,\n    payload,\n    payloadAPI: isGraphQL ? 'GraphQL' : 'REST',\n    payloadDataLoader: undefined!,\n    payloadUploadSizes: {},\n    port: urlProperties.port,\n    protocol: urlProperties.protocol,\n    query,\n    routeParams: params || {},\n    search: urlProperties.search,\n    searchParams: urlProperties.searchParams,\n    t: i18n.t,\n    transactionID: undefined,\n    user: null,\n  }\n\n  const req: PayloadRequest = Object.assign(request, customRequest)\n\n  req.payloadDataLoader = getDataLoader(req)\n\n  const { responseHeaders, user } = await executeAuthStrategies({\n    canSetHeaders,\n    headers: req.headers,\n    isGraphQL,\n    payload,\n  })\n\n  req.user = user\n\n  if (responseHeaders) {\n    req.responseHeaders = responseHeaders\n  }\n\n  return req\n}\n"],"names":["initI18n","qs","executeAuthStrategies","getDataLoader","getPayload","sanitizeLocales","formatAdminURL","getRequestLanguage","parseCookies","createPayloadRequest","canSetHeaders","config","configPromise","params","payloadInstanceCacheKey","request","cookies","headers","payload","cron","key","localization","urlProperties","URL","url","pathname","searchParams","isGraphQL","graphQL","disable","apiRoute","routes","api","path","language","i18n","context","locale","get","search","queryToParse","query","parse","arrayLimit","depth","ignoreQueryPrefix","fallbackFromRequest","fallbackLocale","locales","customRequest","hash","host","href","origin","payloadAPI","payloadDataLoader","undefined","payloadUploadSizes","port","protocol","routeParams","t","transactionID","user","req","Object","assign","responseHeaders"],"mappings":"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"}

package/dist/utilities/deepCopyObject.d.ts

@@ -0,0 +1,22 @@
+import type { JsonValue } from '../types/index.js';
+export declare const deepCopyObject: <T>(o: T) => T;
+/**
+ * A deepCopyObject implementation which only works for JSON objects and arrays, and is faster than
+ * JSON.parse(JSON.stringify(obj))
+ *
+ * @param value The JSON value to be cloned. There are two invariants. 1) It must not contain circles
+ *              as JSON does not allow it. This function will cause infinite loop for such values by
+ *              design. 2) It must contain JSON values only. Other values like `Date`, `Regexp`, `Map`,
+ *              `Set`, `Buffer`, ... are not allowed.
+ * @returns The cloned JSON value.
+ */
+export declare function deepCopyObjectSimple<T extends JsonValue>(value: T, filterUndefined?: boolean): T;
+export declare function deepCopyObjectSimpleWithoutReactComponents<T extends JsonValue>(value: T, opts?: {
+    excludeFiles?: boolean;
+}): T;
+/**
+ * A deepCopyObject implementation which is slower than deepCopyObject, but more correct.
+ * Can be used if correctness is more important than speed. Supports circular dependencies
+ */
+export declare function deepCopyObjectComplex<T>(object: T, cache?: WeakMap<any, any>): T;
+//# sourceMappingURL=deepCopyObject.d.ts.map

package/dist/utilities/deepCopyObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepCopyObject.d.ts","sourceRoot":"","sources":["../../src/utilities/deepCopyObject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AA2DlD,eAAO,MAAM,cAAc,GAAI,CAAC,KAAK,CAAC,KAAG,CAiCxC,CAAA;AAQD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,eAAe,UAAQ,GAAG,CAAC,CAwB9F;AAED,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,SAAS,EAC5E,KAAK,EAAE,CAAC,EACR,IAAI,GAAE;IACJ,YAAY,CAAC,EAAE,OAAO,CAAA;CAClB,GACL,CAAC,CAoCH;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,GAAE,OAAO,CAAC,GAAG,EAAE,GAAG,CAAiB,GAAG,CAAC,CAqE/F"}

package/dist/utilities/deepCopyObject.js

@@ -0,0 +1,201 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /*
+Main deepCopyObject handling - from rfdc: https://github.com/davidmarkclements/rfdc/blob/master/index.js
+
+Copyright 2019 "David Mark Clements <david.mark.clements@gmail.com>"
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+*/ function copyBuffer(cur) {
+    if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+    }
+    return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+}
+const constructorHandlers = new Map();
+constructorHandlers.set(Date, (o)=>new Date(o));
+constructorHandlers.set(Map, (o, fn)=>new Map(cloneArray(Array.from(o), fn)));
+constructorHandlers.set(Set, (o, fn)=>new Set(cloneArray(Array.from(o), fn)));
+constructorHandlers.set(RegExp, (regex)=>new RegExp(regex.source, regex.flags));
+let handler = null;
+function cloneArray(a, fn) {
+    const keys = Object.keys(a);
+    const a2 = new Array(keys.length);
+    for(let i = 0; i < keys.length; i++){
+        const k = keys[i];
+        const cur = a[k];
+        if (typeof cur !== 'object' || cur === null) {
+            a2[k] = cur;
+        } else if (cur instanceof RegExp) {
+            a2[k] = new RegExp(cur.source, cur.flags);
+        } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            a2[k] = handler(cur, fn);
+        } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+        } else {
+            a2[k] = fn(cur);
+        }
+    }
+    return a2;
+}
+export const deepCopyObject = (o)=>{
+    if (typeof o !== 'object' || o === null) {
+        return o;
+    }
+    if (Array.isArray(o)) {
+        return cloneArray(o, deepCopyObject);
+    }
+    if (o instanceof RegExp) {
+        return new RegExp(o.source, o.flags);
+    }
+    if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) {
+        return handler(o, deepCopyObject);
+    }
+    const o2 = {};
+    for(const k in o){
+        if (Object.hasOwnProperty.call(o, k) === false) {
+            continue;
+        }
+        const cur = o[k];
+        if (typeof cur !== 'object' || cur === null) {
+            o2[k] = cur;
+        } else if (cur instanceof RegExp) {
+            o2[k] = new RegExp(cur.source, cur.flags);
+        } else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) {
+            o2[k] = handler(cur, deepCopyObject);
+        } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+        } else {
+            o2[k] = deepCopyObject(cur);
+        }
+    }
+    return o2;
+};
+/*
+Fast deepCopyObjectSimple handling - from fast-json-clone: https://github.com/rhysd/fast-json-clone
+
+Benchmark: https://github.com/AlessioGr/fastest-deep-clone-json/blob/main/test/benchmark.js
+*/ /**
+ * A deepCopyObject implementation which only works for JSON objects and arrays, and is faster than
+ * JSON.parse(JSON.stringify(obj))
+ *
+ * @param value The JSON value to be cloned. There are two invariants. 1) It must not contain circles
+ *              as JSON does not allow it. This function will cause infinite loop for such values by
+ *              design. 2) It must contain JSON values only. Other values like `Date`, `Regexp`, `Map`,
+ *              `Set`, `Buffer`, ... are not allowed.
+ * @returns The cloned JSON value.
+ */ export function deepCopyObjectSimple(value, filterUndefined = false) {
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    } else if (Array.isArray(value)) {
+        return value.map((e)=>typeof e !== 'object' || e === null ? e : deepCopyObjectSimple(e, filterUndefined));
+    } else {
+        if (value instanceof Date) {
+            return new Date(value);
+        }
+        const ret = {};
+        for(const k in value){
+            const v = value[k];
+            if (filterUndefined && v === undefined) {
+                continue;
+            }
+            ret[k] = typeof v !== 'object' || v === null ? v : deepCopyObjectSimple(v, filterUndefined);
+        }
+        return ret;
+    }
+}
+export function deepCopyObjectSimpleWithoutReactComponents(value, opts = {}) {
+    if (typeof value === 'object' && value !== null && '$$typeof' in value && typeof value.$$typeof === 'symbol') {
+        return undefined;
+    } else if (typeof value !== 'object' || value === null) {
+        return value;
+    } else if (Array.isArray(value)) {
+        return value.map((e)=>typeof e !== 'object' || e === null ? e : deepCopyObjectSimpleWithoutReactComponents(e, opts));
+    } else {
+        // Handle File objects by returning them as-is (don't serialize to plain object) or exclude if excludeFiles is provided
+        if (value instanceof File) {
+            if (opts.excludeFiles) {
+                return undefined;
+            }
+            return value;
+        }
+        if (value instanceof Date) {
+            return new Date(value);
+        }
+        const ret = {};
+        for(const k in value){
+            const v = value[k];
+            ret[k] = typeof v !== 'object' || v === null ? v : deepCopyObjectSimpleWithoutReactComponents(v, opts);
+        }
+        return ret;
+    }
+}
+/**
+ * A deepCopyObject implementation which is slower than deepCopyObject, but more correct.
+ * Can be used if correctness is more important than speed. Supports circular dependencies
+ */ export function deepCopyObjectComplex(object, cache = new WeakMap()) {
+    if (object === null) {
+        return null;
+    }
+    if (cache.has(object)) {
+        return cache.get(object);
+    }
+    // Handle File
+    if (object instanceof File) {
+        return object;
+    }
+    // Handle Date
+    if (object instanceof Date) {
+        return new Date(object.getTime());
+    }
+    // Handle RegExp
+    if (object instanceof RegExp) {
+        return new RegExp(object.source, object.flags);
+    }
+    // Handle Map
+    if (object instanceof Map) {
+        const clonedMap = new Map();
+        cache.set(object, clonedMap);
+        for (const [key, value] of object.entries()){
+            clonedMap.set(key, deepCopyObjectComplex(value, cache));
+        }
+        return clonedMap;
+    }
+    // Handle Set
+    if (object instanceof Set) {
+        const clonedSet = new Set();
+        cache.set(object, clonedSet);
+        for (const value of object.values()){
+            clonedSet.add(deepCopyObjectComplex(value, cache));
+        }
+        return clonedSet;
+    }
+    // Handle Array and Object
+    if (typeof object === 'object' && object !== null) {
+        if ('$$typeof' in object && typeof object.$$typeof === 'symbol') {
+            return object;
+        }
+        const clonedObject = Array.isArray(object) ? [] : Object.create(Object.getPrototypeOf(object));
+        cache.set(object, clonedObject);
+        for(const key in object){
+            if (Object.prototype.hasOwnProperty.call(object, key) || Object.getOwnPropertySymbols(object).includes(key)) {
+                clonedObject[key] = deepCopyObjectComplex(object[key], cache);
+            }
+        }
+        return clonedObject;
+    }
+    // Handle all other cases
+    return object;
+}
+
+//# sourceMappingURL=deepCopyObject.js.map