payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/utilities/resolveValidationLocales.d.ts

@@ -0,0 +1,32 @@
+import type { TypedLocale } from '../index.js';
+import type { PayloadRequest } from '../types/index.js';
+/**
+ * Locales accepted by collection and global on-demand validation.
+ *
+ * A non-empty array validates its unique locale codes in the order provided. `'all'` validates
+ * every locale available to the request. When omitted by the public APIs, validation uses the
+ * request locale, or the configured default locale.
+ */
+export type ValidationLocaleSelector = 'all' | readonly [TypedLocale, ...TypedLocale[]] | TypedLocale;
+export declare function resolveValidationLocales({ locale, req, }: {
+    locale: ValidationLocaleSelector;
+    req: PayloadRequest;
+}): Promise<TypedLocale[]>;
+/**
+ * A request that already carries a transaction ID shares a database session with the transaction
+ * it was cloned from. Concurrent operations on one session are unsafe, so locale passes must run
+ * one at a time rather than with the default concurrency.
+ */
+export declare function resolveValidationConcurrency(req: Partial<PayloadRequest> | undefined): number | undefined;
+export declare function runValidationLocalePasses<TResult>({ concurrency, locales, validate, }: {
+    /**
+     * Maximum number of locale passes to run at once. Pass `1` when the request being validated
+     * shares a database session with an already-open transaction, since concurrent operations on
+     * one session are unsafe.
+     * @default 3
+     */
+    concurrency?: number;
+    locales: TypedLocale[];
+    validate: (locale: TypedLocale) => Promise<TResult>;
+}): Promise<TResult[]>;
+//# sourceMappingURL=resolveValidationLocales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveValidationLocales.d.ts","sourceRoot":"","sources":["../../src/utilities/resolveValidationLocales.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAMvD;;;;;;GAMG;AAEH,MAAM,MAAM,wBAAwB,GAChC,KAAK,GACL,SAAS,CAAC,WAAW,EAAE,GAAG,WAAW,EAAE,CAAC,GACxC,WAAW,CAAA;AAKf,wBAAsB,wBAAwB,CAAC,EAC7C,MAAM,EACN,GAAG,GACJ,EAAE;IACD,MAAM,EAAE,wBAAwB,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAmEzB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,GACvC,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,EACvD,WAAyC,EACzC,OAAO,EACP,QAAQ,GACT,EAAE;IACD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACpD,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAUrB"}

package/dist/utilities/resolveValidationLocales.js

@@ -0,0 +1,74 @@
+import { APIError } from '../errors/index.js';
+import { httpStatus } from './httpStatus.js';
+/* eslint-enable @typescript-eslint/no-redundant-type-constituents */ const validationLocaleConcurrency = 3;
+export async function resolveValidationLocales({ locale, req }) {
+    const localization = req.payload.config.localization;
+    if (!localization) {
+        if (locale === 'all') {
+            return [
+                null
+            ];
+        }
+        const locales = Array.isArray(locale) ? locale : [
+            locale
+        ];
+        if (locales.length === 0 || locales.some((value)=>value !== null)) {
+            throw new APIError('Validation requires a locale.', httpStatus.BAD_REQUEST);
+        }
+        return [
+            ...new Set(locales)
+        ];
+    }
+    let availableLocaleCodes = localization.localeCodes;
+    if (localization.filterAvailableLocales) {
+        const availableLocales = await localization.filterAvailableLocales({
+            locales: localization.locales,
+            req
+        });
+        availableLocaleCodes = availableLocales.map((availableLocale)=>typeof availableLocale === 'string' ? availableLocale : availableLocale.code);
+    }
+    if (locale === 'all') {
+        if (availableLocaleCodes.length === 0) {
+            throw new APIError('No validation locales are available.', httpStatus.BAD_REQUEST);
+        }
+        return [
+            ...new Set(availableLocaleCodes)
+        ];
+    }
+    const requestedLocales = Array.isArray(locale) ? locale : [
+        locale
+    ];
+    if (requestedLocales.length === 0 || requestedLocales.some((requestedLocale)=>typeof requestedLocale !== 'string' || requestedLocale.length === 0)) {
+        throw new APIError('Validation requires a locale.', httpStatus.BAD_REQUEST);
+    }
+    const locales = [
+        ...new Set(requestedLocales)
+    ];
+    for (const requestedLocale of locales){
+        if (!localization.localeCodes.includes(requestedLocale)) {
+            throw new APIError(`Validation locale "${String(requestedLocale)}" is not configured.`, httpStatus.BAD_REQUEST);
+        }
+        if (!availableLocaleCodes.includes(requestedLocale)) {
+            throw new APIError(`Validation locale "${String(requestedLocale)}" is not available.`, httpStatus.BAD_REQUEST);
+        }
+    }
+    return locales;
+}
+/**
+ * A request that already carries a transaction ID shares a database session with the transaction
+ * it was cloned from. Concurrent operations on one session are unsafe, so locale passes must run
+ * one at a time rather than with the default concurrency.
+ */ export function resolveValidationConcurrency(req) {
+    return req?.transactionID ? 1 : undefined;
+}
+export async function runValidationLocalePasses({ concurrency = validationLocaleConcurrency, locales, validate }) {
+    const batchSize = Math.max(1, Math.min(concurrency, locales.length));
+    const results = [];
+    for(let batchStart = 0; batchStart < locales.length; batchStart += batchSize){
+        const batch = locales.slice(batchStart, batchStart + batchSize);
+        results.push(...await Promise.all(batch.map((locale)=>validate(locale))));
+    }
+    return results;
+}
+
+//# sourceMappingURL=resolveValidationLocales.js.map

package/dist/utilities/resolveValidationLocales.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/resolveValidationLocales.ts"],"sourcesContent":["import type { TypedLocale } from '../index.js'\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { APIError } from '../errors/index.js'\nimport { httpStatus } from './httpStatus.js'\n\n// TypedLocale is narrowed by generated types, while its untyped fallback intentionally includes string.\n/**\n * Locales accepted by collection and global on-demand validation.\n *\n * A non-empty array validates its unique locale codes in the order provided. `'all'` validates\n * every locale available to the request. When omitted by the public APIs, validation uses the\n * request locale, or the configured default locale.\n */\n/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\nexport type ValidationLocaleSelector =\n  | 'all'\n  | readonly [TypedLocale, ...TypedLocale[]]\n  | TypedLocale\n/* eslint-enable @typescript-eslint/no-redundant-type-constituents */\n\nconst validationLocaleConcurrency = 3\n\nexport async function resolveValidationLocales({\n  locale,\n  req,\n}: {\n  locale: ValidationLocaleSelector\n  req: PayloadRequest\n}): Promise<TypedLocale[]> {\n  const localization = req.payload.config.localization\n\n  if (!localization) {\n    if (locale === 'all') {\n      return [null] as TypedLocale[]\n    }\n\n    const locales = Array.isArray(locale) ? locale : [locale]\n\n    if (locales.length === 0 || locales.some((value) => value !== null)) {\n      throw new APIError('Validation requires a locale.', httpStatus.BAD_REQUEST)\n    }\n\n    return [...new Set(locales)]\n  }\n\n  let availableLocaleCodes = localization.localeCodes\n\n  if (localization.filterAvailableLocales) {\n    const availableLocales = await localization.filterAvailableLocales({\n      locales: localization.locales,\n      req,\n    })\n    availableLocaleCodes = availableLocales.map((availableLocale) =>\n      typeof availableLocale === 'string' ? availableLocale : availableLocale.code,\n    )\n  }\n\n  if (locale === 'all') {\n    if (availableLocaleCodes.length === 0) {\n      throw new APIError('No validation locales are available.', httpStatus.BAD_REQUEST)\n    }\n\n    return [...new Set(availableLocaleCodes)] as TypedLocale[]\n  }\n\n  const requestedLocales = Array.isArray(locale) ? locale : [locale]\n\n  if (\n    requestedLocales.length === 0 ||\n    requestedLocales.some(\n      (requestedLocale) => typeof requestedLocale !== 'string' || requestedLocale.length === 0,\n    )\n  ) {\n    throw new APIError('Validation requires a locale.', httpStatus.BAD_REQUEST)\n  }\n\n  const locales = [...new Set(requestedLocales)]\n\n  for (const requestedLocale of locales) {\n    if (!localization.localeCodes.includes(requestedLocale as string)) {\n      throw new APIError(\n        `Validation locale \"${String(requestedLocale)}\" is not configured.`,\n        httpStatus.BAD_REQUEST,\n      )\n    }\n\n    if (!availableLocaleCodes.includes(requestedLocale as string)) {\n      throw new APIError(\n        `Validation locale \"${String(requestedLocale)}\" is not available.`,\n        httpStatus.BAD_REQUEST,\n      )\n    }\n  }\n\n  return locales\n}\n\n/**\n * A request that already carries a transaction ID shares a database session with the transaction\n * it was cloned from. Concurrent operations on one session are unsafe, so locale passes must run\n * one at a time rather than with the default concurrency.\n */\nexport function resolveValidationConcurrency(\n  req: Partial<PayloadRequest> | undefined,\n): number | undefined {\n  return req?.transactionID ? 1 : undefined\n}\n\nexport async function runValidationLocalePasses<TResult>({\n  concurrency = validationLocaleConcurrency,\n  locales,\n  validate,\n}: {\n  /**\n   * Maximum number of locale passes to run at once. Pass `1` when the request being validated\n   * shares a database session with an already-open transaction, since concurrent operations on\n   * one session are unsafe.\n   * @default 3\n   */\n  concurrency?: number\n  locales: TypedLocale[]\n  validate: (locale: TypedLocale) => Promise<TResult>\n}): Promise<TResult[]> {\n  const batchSize = Math.max(1, Math.min(concurrency, locales.length))\n  const results: TResult[] = []\n\n  for (let batchStart = 0; batchStart < locales.length; batchStart += batchSize) {\n    const batch = locales.slice(batchStart, batchStart + batchSize)\n    results.push(...(await Promise.all(batch.map((locale) => validate(locale)))))\n  }\n\n  return results\n}\n"],"names":["APIError","httpStatus","validationLocaleConcurrency","resolveValidationLocales","locale","req","localization","payload","config","locales","Array","isArray","length","some","value","BAD_REQUEST","Set","availableLocaleCodes","localeCodes","filterAvailableLocales","availableLocales","map","availableLocale","code","requestedLocales","requestedLocale","includes","String","resolveValidationConcurrency","transactionID","undefined","runValidationLocalePasses","concurrency","validate","batchSize","Math","max","min","results","batchStart","batch","slice","push","Promise","all"],"mappings":"AAGA,SAASA,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,UAAU,QAAQ,kBAAiB;AAe5C,mEAAmE,GAEnE,MAAMC,8BAA8B;AAEpC,OAAO,eAAeC,yBAAyB,EAC7CC,MAAM,EACNC,GAAG,EAIJ;IACC,MAAMC,eAAeD,IAAIE,OAAO,CAACC,MAAM,CAACF,YAAY;IAEpD,IAAI,CAACA,cAAc;QACjB,IAAIF,WAAW,OAAO;YACpB,OAAO;gBAAC;aAAK;QACf;QAEA,MAAMK,UAAUC,MAAMC,OAAO,CAACP,UAAUA,SAAS;YAACA;SAAO;QAEzD,IAAIK,QAAQG,MAAM,KAAK,KAAKH,QAAQI,IAAI,CAAC,CAACC,QAAUA,UAAU,OAAO;YACnE,MAAM,IAAId,SAAS,iCAAiCC,WAAWc,WAAW;QAC5E;QAEA,OAAO;eAAI,IAAIC,IAAIP;SAAS;IAC9B;IAEA,IAAIQ,uBAAuBX,aAAaY,WAAW;IAEnD,IAAIZ,aAAaa,sBAAsB,EAAE;QACvC,MAAMC,mBAAmB,MAAMd,aAAaa,sBAAsB,CAAC;YACjEV,SAASH,aAAaG,OAAO;YAC7BJ;QACF;QACAY,uBAAuBG,iBAAiBC,GAAG,CAAC,CAACC,kBAC3C,OAAOA,oBAAoB,WAAWA,kBAAkBA,gBAAgBC,IAAI;IAEhF;IAEA,IAAInB,WAAW,OAAO;QACpB,IAAIa,qBAAqBL,MAAM,KAAK,GAAG;YACrC,MAAM,IAAIZ,SAAS,wCAAwCC,WAAWc,WAAW;QACnF;QAEA,OAAO;eAAI,IAAIC,IAAIC;SAAsB;IAC3C;IAEA,MAAMO,mBAAmBd,MAAMC,OAAO,CAACP,UAAUA,SAAS;QAACA;KAAO;IAElE,IACEoB,iBAAiBZ,MAAM,KAAK,KAC5BY,iBAAiBX,IAAI,CACnB,CAACY,kBAAoB,OAAOA,oBAAoB,YAAYA,gBAAgBb,MAAM,KAAK,IAEzF;QACA,MAAM,IAAIZ,SAAS,iCAAiCC,WAAWc,WAAW;IAC5E;IAEA,MAAMN,UAAU;WAAI,IAAIO,IAAIQ;KAAkB;IAE9C,KAAK,MAAMC,mBAAmBhB,QAAS;QACrC,IAAI,CAACH,aAAaY,WAAW,CAACQ,QAAQ,CAACD,kBAA4B;YACjE,MAAM,IAAIzB,SACR,CAAC,mBAAmB,EAAE2B,OAAOF,iBAAiB,oBAAoB,CAAC,EACnExB,WAAWc,WAAW;QAE1B;QAEA,IAAI,CAACE,qBAAqBS,QAAQ,CAACD,kBAA4B;YAC7D,MAAM,IAAIzB,SACR,CAAC,mBAAmB,EAAE2B,OAAOF,iBAAiB,mBAAmB,CAAC,EAClExB,WAAWc,WAAW;QAE1B;IACF;IAEA,OAAON;AACT;AAEA;;;;CAIC,GACD,OAAO,SAASmB,6BACdvB,GAAwC;IAExC,OAAOA,KAAKwB,gBAAgB,IAAIC;AAClC;AAEA,OAAO,eAAeC,0BAAmC,EACvDC,cAAc9B,2BAA2B,EACzCO,OAAO,EACPwB,QAAQ,EAWT;IACC,MAAMC,YAAYC,KAAKC,GAAG,CAAC,GAAGD,KAAKE,GAAG,CAACL,aAAavB,QAAQG,MAAM;IAClE,MAAM0B,UAAqB,EAAE;IAE7B,IAAK,IAAIC,aAAa,GAAGA,aAAa9B,QAAQG,MAAM,EAAE2B,cAAcL,UAAW;QAC7E,MAAMM,QAAQ/B,QAAQgC,KAAK,CAACF,YAAYA,aAAaL;QACrDI,QAAQI,IAAI,IAAK,MAAMC,QAAQC,GAAG,CAACJ,MAAMnB,GAAG,CAAC,CAACjB,SAAW6B,SAAS7B;IACpE;IAEA,OAAOkC;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"routeError.d.ts","sourceRoot":"","sources":["../../src/utilities/routeError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAQhD,eAAO,MAAM,UAAU,8DAKpB;IACD,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,GAAG,EAAE,QAAQ,CAAA;IACb,GAAG,EAAE,cAAc,GAAG,OAAO,CAAA;CAC9B,KAAG,OAAO,CAAC,QAAQ,CA+FnB,CAAA"}
+{"version":3,"file":"routeError.d.ts","sourceRoot":"","sources":["../../src/utilities/routeError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAShD,eAAO,MAAM,UAAU,8DAKpB;IACD,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,GAAG,EAAE,QAAQ,CAAA;IACb,GAAG,EAAE,cAAc,GAAG,OAAO,CAAA;CAC9B,KAAG,OAAO,CAAC,QAAQ,CA+FnB,CAAA"}

package/dist/utilities/routeError.js

@@ -1,8 +1,8 @@
-import { status as httpStatus } from 'http-status';
 import { APIError } from '../errors/APIError.js';
 import { getPayload } from '../index.js';
 import { formatErrors } from './formatErrors.js';
 import { headersWithCors } from './headersWithCors.js';
+import { httpStatus } from './httpStatus.js';
 import { isErrorPublic } from './isErrorPublic.js';
 import { logError } from './logError.js';
 import { mergeHeaders } from './mergeHeaders.js';

package/dist/utilities/routeError.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/routeError.ts"],"sourcesContent":["import { status as httpStatus } from 'http-status'\n\nimport type { Collection } from '../collections/config/types.js'\nimport type { ErrorResult, SanitizedConfig } from '../config/types.js'\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { getPayload } from '../index.js'\nimport { formatErrors } from './formatErrors.js'\nimport { headersWithCors } from './headersWithCors.js'\nimport { isErrorPublic } from './isErrorPublic.js'\nimport { logError } from './logError.js'\nimport { mergeHeaders } from './mergeHeaders.js'\n\nexport const routeError = async ({\n  collection,\n  config: configArg,\n  err,\n  req: incomingReq,\n}: {\n  collection?: Collection\n  config: Promise<SanitizedConfig> | SanitizedConfig\n  err: APIError\n  req: PayloadRequest | Request\n}): Promise<Response> => {\n  if ('payloadInitError' in err && err.payloadInitError === true) {\n    // do not attempt initializing Payload if the error is due to a failed initialization. Otherwise,\n    // it will cause an infinite loop of initialization attempts and endless error responses, without\n    // actually logging the error, as the error logging code will never be reached.\n    console.error(err)\n    return Response.json(\n      {\n        message: 'There was an error initializing Payload',\n      },\n      { status: httpStatus.INTERNAL_SERVER_ERROR },\n    )\n  }\n\n  let payload = incomingReq && 'payload' in incomingReq && incomingReq?.payload\n\n  if (!payload) {\n    try {\n      payload = await getPayload({ config: configArg, cron: true })\n    } catch (ignore) {\n      return Response.json(\n        {\n          message: 'There was an error initializing Payload',\n        },\n        { status: httpStatus.INTERNAL_SERVER_ERROR },\n      )\n    }\n  }\n\n  let response = formatErrors(err)\n\n  let status = err.status || httpStatus.INTERNAL_SERVER_ERROR\n\n  logError({ err, payload })\n\n  const req = incomingReq as PayloadRequest\n\n  req.payload = payload\n  const headers = headersWithCors({\n    headers: new Headers(),\n    req,\n  })\n\n  const { config } = payload\n\n  // Internal server errors can contain anything, including potentially sensitive data.\n  // Therefore, error details will be hidden from the response unless `config.debug` is `true`\n  if (!isErrorPublic(err, config)) {\n    response = formatErrors(new APIError('Something went wrong.'))\n  }\n\n  if (config.debug && config.debug === true) {\n    response.stack = err.stack\n  }\n\n  if (collection) {\n    await collection.config.hooks.afterError?.reduce(async (promise, hook) => {\n      await promise\n\n      const result = await hook({\n        collection: collection.config,\n        context: req.context,\n        error: err,\n        req,\n        result: response,\n      })\n\n      if (result) {\n        response = (result.response as ErrorResult) || response\n        status = result.status || status\n      }\n    }, Promise.resolve())\n  }\n\n  await config.hooks.afterError?.reduce(async (promise, hook) => {\n    await promise\n\n    const result = await hook({\n      collection: collection?.config,\n      context: req.context,\n      error: err,\n      req,\n      result: response,\n    })\n\n    if (result) {\n      response = (result.response as ErrorResult) || response\n      status = result.status || status\n    }\n  }, Promise.resolve())\n\n  return Response.json(response, {\n    headers: req.responseHeaders ? mergeHeaders(req.responseHeaders, headers) : headers,\n    status,\n  })\n}\n"],"names":["status","httpStatus","APIError","getPayload","formatErrors","headersWithCors","isErrorPublic","logError","mergeHeaders","routeError","collection","config","configArg","err","req","incomingReq","payloadInitError","console","error","Response","json","message","INTERNAL_SERVER_ERROR","payload","cron","ignore","response","headers","Headers","debug","stack","hooks","afterError","reduce","promise","hook","result","context","Promise","resolve","responseHeaders"],"mappings":"AAAA,SAASA,UAAUC,UAAU,QAAQ,cAAa;AAMlD,SAASC,QAAQ,QAAQ,wBAAuB;AAChD,SAASC,UAAU,QAAQ,cAAa;AACxC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,QAAQ,QAAQ,gBAAe;AACxC,SAASC,YAAY,QAAQ,oBAAmB;AAEhD,OAAO,MAAMC,aAAa,OAAO,EAC/BC,UAAU,EACVC,QAAQC,SAAS,EACjBC,GAAG,EACHC,KAAKC,WAAW,EAMjB;IACC,IAAI,sBAAsBF,OAAOA,IAAIG,gBAAgB,KAAK,MAAM;QAC9D,iGAAiG;QACjG,iGAAiG;QACjG,+EAA+E;QAC/EC,QAAQC,KAAK,CAACL;QACd,OAAOM,SAASC,IAAI,CAClB;YACEC,SAAS;QACX,GACA;YAAErB,QAAQC,WAAWqB,qBAAqB;QAAC;IAE/C;IAEA,IAAIC,UAAUR,eAAe,aAAaA,eAAeA,aAAaQ;IAEtE,IAAI,CAACA,SAAS;QACZ,IAAI;YACFA,UAAU,MAAMpB,WAAW;gBAAEQ,QAAQC;gBAAWY,MAAM;YAAK;QAC7D,EAAE,OAAOC,QAAQ;YACf,OAAON,SAASC,IAAI,CAClB;gBACEC,SAAS;YACX,GACA;gBAAErB,QAAQC,WAAWqB,qBAAqB;YAAC;QAE/C;IACF;IAEA,IAAII,WAAWtB,aAAaS;IAE5B,IAAIb,SAASa,IAAIb,MAAM,IAAIC,WAAWqB,qBAAqB;IAE3Df,SAAS;QAAEM;QAAKU;IAAQ;IAExB,MAAMT,MAAMC;IAEZD,IAAIS,OAAO,GAAGA;IACd,MAAMI,UAAUtB,gBAAgB;QAC9BsB,SAAS,IAAIC;QACbd;IACF;IAEA,MAAM,EAAEH,MAAM,EAAE,GAAGY;IAEnB,qFAAqF;IACrF,4FAA4F;IAC5F,IAAI,CAACjB,cAAcO,KAAKF,SAAS;QAC/Be,WAAWtB,aAAa,IAAIF,SAAS;IACvC;IAEA,IAAIS,OAAOkB,KAAK,IAAIlB,OAAOkB,KAAK,KAAK,MAAM;QACzCH,SAASI,KAAK,GAAGjB,IAAIiB,KAAK;IAC5B;IAEA,IAAIpB,YAAY;QACd,MAAMA,WAAWC,MAAM,CAACoB,KAAK,CAACC,UAAU,EAAEC,OAAO,OAAOC,SAASC;YAC/D,MAAMD;YAEN,MAAME,SAAS,MAAMD,KAAK;gBACxBzB,YAAYA,WAAWC,MAAM;gBAC7B0B,SAASvB,IAAIuB,OAAO;gBACpBnB,OAAOL;gBACPC;gBACAsB,QAAQV;YACV;YAEA,IAAIU,QAAQ;gBACVV,WAAW,AAACU,OAAOV,QAAQ,IAAoBA;gBAC/C1B,SAASoC,OAAOpC,MAAM,IAAIA;YAC5B;QACF,GAAGsC,QAAQC,OAAO;IACpB;IAEA,MAAM5B,OAAOoB,KAAK,CAACC,UAAU,EAAEC,OAAO,OAAOC,SAASC;QACpD,MAAMD;QAEN,MAAME,SAAS,MAAMD,KAAK;YACxBzB,YAAYA,YAAYC;YACxB0B,SAASvB,IAAIuB,OAAO;YACpBnB,OAAOL;YACPC;YACAsB,QAAQV;QACV;QAEA,IAAIU,QAAQ;YACVV,WAAW,AAACU,OAAOV,QAAQ,IAAoBA;YAC/C1B,SAASoC,OAAOpC,MAAM,IAAIA;QAC5B;IACF,GAAGsC,QAAQC,OAAO;IAElB,OAAOpB,SAASC,IAAI,CAACM,UAAU;QAC7BC,SAASb,IAAI0B,eAAe,GAAGhC,aAAaM,IAAI0B,eAAe,EAAEb,WAAWA;QAC5E3B;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../src/utilities/routeError.ts"],"sourcesContent":["import type { Collection } from '../collections/config/types.js'\nimport type { ErrorResult, SanitizedConfig } from '../config/types.js'\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { getPayload } from '../index.js'\nimport { formatErrors } from './formatErrors.js'\nimport { headersWithCors } from './headersWithCors.js'\nimport { httpStatus } from './httpStatus.js'\nimport { isErrorPublic } from './isErrorPublic.js'\nimport { logError } from './logError.js'\nimport { mergeHeaders } from './mergeHeaders.js'\n\nexport const routeError = async ({\n  collection,\n  config: configArg,\n  err,\n  req: incomingReq,\n}: {\n  collection?: Collection\n  config: Promise<SanitizedConfig> | SanitizedConfig\n  err: APIError\n  req: PayloadRequest | Request\n}): Promise<Response> => {\n  if ('payloadInitError' in err && err.payloadInitError === true) {\n    // do not attempt initializing Payload if the error is due to a failed initialization. Otherwise,\n    // it will cause an infinite loop of initialization attempts and endless error responses, without\n    // actually logging the error, as the error logging code will never be reached.\n    console.error(err)\n    return Response.json(\n      {\n        message: 'There was an error initializing Payload',\n      },\n      { status: httpStatus.INTERNAL_SERVER_ERROR },\n    )\n  }\n\n  let payload = incomingReq && 'payload' in incomingReq && incomingReq?.payload\n\n  if (!payload) {\n    try {\n      payload = await getPayload({ config: configArg, cron: true })\n    } catch (ignore) {\n      return Response.json(\n        {\n          message: 'There was an error initializing Payload',\n        },\n        { status: httpStatus.INTERNAL_SERVER_ERROR },\n      )\n    }\n  }\n\n  let response = formatErrors(err)\n\n  let status = err.status || httpStatus.INTERNAL_SERVER_ERROR\n\n  logError({ err, payload })\n\n  const req = incomingReq as PayloadRequest\n\n  req.payload = payload\n  const headers = headersWithCors({\n    headers: new Headers(),\n    req,\n  })\n\n  const { config } = payload\n\n  // Internal server errors can contain anything, including potentially sensitive data.\n  // Therefore, error details will be hidden from the response unless `config.debug` is `true`\n  if (!isErrorPublic(err, config)) {\n    response = formatErrors(new APIError('Something went wrong.'))\n  }\n\n  if (config.debug && config.debug === true) {\n    response.stack = err.stack\n  }\n\n  if (collection) {\n    await collection.config.hooks.afterError?.reduce(async (promise, hook) => {\n      await promise\n\n      const result = await hook({\n        collection: collection.config,\n        context: req.context,\n        error: err,\n        req,\n        result: response,\n      })\n\n      if (result) {\n        response = (result.response as ErrorResult) || response\n        status = result.status || status\n      }\n    }, Promise.resolve())\n  }\n\n  await config.hooks.afterError?.reduce(async (promise, hook) => {\n    await promise\n\n    const result = await hook({\n      collection: collection?.config,\n      context: req.context,\n      error: err,\n      req,\n      result: response,\n    })\n\n    if (result) {\n      response = (result.response as ErrorResult) || response\n      status = result.status || status\n    }\n  }, Promise.resolve())\n\n  return Response.json(response, {\n    headers: req.responseHeaders ? mergeHeaders(req.responseHeaders, headers) : headers,\n    status,\n  })\n}\n"],"names":["APIError","getPayload","formatErrors","headersWithCors","httpStatus","isErrorPublic","logError","mergeHeaders","routeError","collection","config","configArg","err","req","incomingReq","payloadInitError","console","error","Response","json","message","status","INTERNAL_SERVER_ERROR","payload","cron","ignore","response","headers","Headers","debug","stack","hooks","afterError","reduce","promise","hook","result","context","Promise","resolve","responseHeaders"],"mappings":"AAIA,SAASA,QAAQ,QAAQ,wBAAuB;AAChD,SAASC,UAAU,QAAQ,cAAa;AACxC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,QAAQ,QAAQ,gBAAe;AACxC,SAASC,YAAY,QAAQ,oBAAmB;AAEhD,OAAO,MAAMC,aAAa,OAAO,EAC/BC,UAAU,EACVC,QAAQC,SAAS,EACjBC,GAAG,EACHC,KAAKC,WAAW,EAMjB;IACC,IAAI,sBAAsBF,OAAOA,IAAIG,gBAAgB,KAAK,MAAM;QAC9D,iGAAiG;QACjG,iGAAiG;QACjG,+EAA+E;QAC/EC,QAAQC,KAAK,CAACL;QACd,OAAOM,SAASC,IAAI,CAClB;YACEC,SAAS;QACX,GACA;YAAEC,QAAQjB,WAAWkB,qBAAqB;QAAC;IAE/C;IAEA,IAAIC,UAAUT,eAAe,aAAaA,eAAeA,aAAaS;IAEtE,IAAI,CAACA,SAAS;QACZ,IAAI;YACFA,UAAU,MAAMtB,WAAW;gBAAES,QAAQC;gBAAWa,MAAM;YAAK;QAC7D,EAAE,OAAOC,QAAQ;YACf,OAAOP,SAASC,IAAI,CAClB;gBACEC,SAAS;YACX,GACA;gBAAEC,QAAQjB,WAAWkB,qBAAqB;YAAC;QAE/C;IACF;IAEA,IAAII,WAAWxB,aAAaU;IAE5B,IAAIS,SAAST,IAAIS,MAAM,IAAIjB,WAAWkB,qBAAqB;IAE3DhB,SAAS;QAAEM;QAAKW;IAAQ;IAExB,MAAMV,MAAMC;IAEZD,IAAIU,OAAO,GAAGA;IACd,MAAMI,UAAUxB,gBAAgB;QAC9BwB,SAAS,IAAIC;QACbf;IACF;IAEA,MAAM,EAAEH,MAAM,EAAE,GAAGa;IAEnB,qFAAqF;IACrF,4FAA4F;IAC5F,IAAI,CAAClB,cAAcO,KAAKF,SAAS;QAC/BgB,WAAWxB,aAAa,IAAIF,SAAS;IACvC;IAEA,IAAIU,OAAOmB,KAAK,IAAInB,OAAOmB,KAAK,KAAK,MAAM;QACzCH,SAASI,KAAK,GAAGlB,IAAIkB,KAAK;IAC5B;IAEA,IAAIrB,YAAY;QACd,MAAMA,WAAWC,MAAM,CAACqB,KAAK,CAACC,UAAU,EAAEC,OAAO,OAAOC,SAASC;YAC/D,MAAMD;YAEN,MAAME,SAAS,MAAMD,KAAK;gBACxB1B,YAAYA,WAAWC,MAAM;gBAC7B2B,SAASxB,IAAIwB,OAAO;gBACpBpB,OAAOL;gBACPC;gBACAuB,QAAQV;YACV;YAEA,IAAIU,QAAQ;gBACVV,WAAW,AAACU,OAAOV,QAAQ,IAAoBA;gBAC/CL,SAASe,OAAOf,MAAM,IAAIA;YAC5B;QACF,GAAGiB,QAAQC,OAAO;IACpB;IAEA,MAAM7B,OAAOqB,KAAK,CAACC,UAAU,EAAEC,OAAO,OAAOC,SAASC;QACpD,MAAMD;QAEN,MAAME,SAAS,MAAMD,KAAK;YACxB1B,YAAYA,YAAYC;YACxB2B,SAASxB,IAAIwB,OAAO;YACpBpB,OAAOL;YACPC;YACAuB,QAAQV;QACV;QAEA,IAAIU,QAAQ;YACVV,WAAW,AAACU,OAAOV,QAAQ,IAAoBA;YAC/CL,SAASe,OAAOf,MAAM,IAAIA;QAC5B;IACF,GAAGiB,QAAQC,OAAO;IAElB,OAAOrB,SAASC,IAAI,CAACO,UAAU;QAC7BC,SAASd,IAAI2B,eAAe,GAAGjC,aAAaM,IAAI2B,eAAe,EAAEb,WAAWA;QAC5EN;IACF;AACF,EAAC"}

package/dist/utilities/runLocaleScopedValidation.d.ts

@@ -0,0 +1,28 @@
+import type { Field } from '../fields/config/types.js';
+import type { Payload, RequestContext, User } from '../index.js';
+import type { JsonObject, PayloadRequest } from '../types/index.js';
+import type { ValidationResult } from '../types/validation.js';
+import { type ValidationLocaleSelector } from './resolveValidationLocales.js';
+/**
+ * Clones the caller's request, scopes it to the requested operation, resolves the selected locales, runs
+ * `runPass` once per locale against an independent request/data clone, and aggregates the field
+ * errors. Shared by the collection and global local validate wrappers so the locale-cloning and
+ * pass-running plumbing has one owner instead of two copies that can drift apart.
+ */
+export declare function runLocaleScopedValidation<TData>({ context, data, dataIsLocaleKeyed, fields, locale, operation, payload, req, runPass, user, }: {
+    context: RequestContext | undefined;
+    data: TData;
+    dataIsLocaleKeyed?: boolean;
+    fields: Field[];
+    locale: undefined | ValidationLocaleSelector;
+    operation?: 'create' | 'update' | 'validate';
+    payload: Payload;
+    req: Partial<PayloadRequest> | undefined;
+    runPass: (args: {
+        data: TData;
+        onValidationData: (data: JsonObject) => void;
+        req: PayloadRequest;
+    }) => Promise<ValidationResult>;
+    user: null | undefined | User;
+}): Promise<ValidationResult>;
+//# sourceMappingURL=runLocaleScopedValidation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runLocaleScopedValidation.d.ts","sourceRoot":"","sources":["../../src/utilities/runLocaleScopedValidation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAW9D,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,+BAA+B,CAAA;AAQtC;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,EACrD,OAAO,EACP,IAAI,EACJ,iBAAyB,EACzB,MAAM,EACN,MAAM,EACN,SAAsB,EACtB,OAAO,EACP,GAAG,EACH,OAAO,EACP,IAAI,GACL,EAAE;IACD,OAAO,EAAE,cAAc,GAAG,SAAS,CAAA;IACnC,IAAI,EAAE,KAAK,CAAA;IACX,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,MAAM,EAAE,SAAS,GAAG,wBAAwB,CAAA;IAC5C,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAA;IAC5C,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,SAAS,CAAA;IACxC,OAAO,EAAE,CAAC,IAAI,EAAE;QACd,IAAI,EAAE,KAAK,CAAA;QACX,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;QAC5C,GAAG,EAAE,cAAc,CAAA;KACpB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAC/B,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,IAAI,CAAA;CAC9B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyE5B"}

package/dist/utilities/runLocaleScopedValidation.js

@@ -0,0 +1,126 @@
+import { cloneValidationContext, cloneValidationData, cloneValidationRequest, cloneValidationUser } from './cloneValidationRequest.js';
+import { createPayloadRequest } from './createPayloadRequest.js';
+import { flattenDataByLocale } from './flattenDataByLocale.js';
+import { isValidationErrorPathLocalized } from './isValidationErrorPathLocalized.js';
+import { resolveValidationConcurrency, resolveValidationLocales, runValidationLocalePasses } from './resolveValidationLocales.js';
+/**
+ * Clones the caller's request, scopes it to the requested operation, resolves the selected locales, runs
+ * `runPass` once per locale against an independent request/data clone, and aggregates the field
+ * errors. Shared by the collection and global local validate wrappers so the locale-cloning and
+ * pass-running plumbing has one owner instead of two copies that can drift apart.
+ */ export async function runLocaleScopedValidation({ context, data, dataIsLocaleKeyed = false, fields, locale, operation = 'validate', payload, req, runPass, user }) {
+    const baseReq = await createPayloadRequest({
+        context: cloneValidationContext({
+            context
+        }),
+        fallbackLocale: false,
+        payload,
+        req: cloneValidationRequest({
+            request: req
+        }),
+        user: cloneValidationUser({
+            user
+        })
+    });
+    baseReq.operation = operation;
+    const localeSelector = locale === undefined ? baseReq.locale ?? null : locale;
+    const locales = await resolveValidationLocales({
+        locale: localeSelector,
+        req: baseReq
+    });
+    const results = await runValidationLocalePasses({
+        concurrency: resolveValidationConcurrency(req),
+        locales,
+        validate: async (validationLocale)=>{
+            const localeReq = await createPayloadRequest({
+                fallbackLocale: false,
+                locale: validationLocale ?? undefined,
+                payload,
+                req: cloneValidationRequest({
+                    request: baseReq
+                })
+            });
+            const validationCandidateData = cloneValidationData({
+                data
+            });
+            const validationData = dataIsLocaleKeyed && validationLocale ? flattenDataByLocale({
+                configBlockReferences: payload.config.blocks,
+                docWithLocales: validationCandidateData,
+                fields,
+                locale: validationLocale
+            }) : validationCandidateData;
+            let mergedValidationData = validationData;
+            const result = await runPass({
+                data: validationData,
+                onValidationData: (mergedData)=>{
+                    mergedValidationData = mergedData;
+                },
+                req: localeReq
+            });
+            return result.errors.map((error)=>({
+                    error,
+                    isLocalized: isValidationErrorPathLocalized({
+                        configBlockReferences: payload.config.blocks,
+                        data: mergedValidationData,
+                        fields,
+                        path: error.path
+                    }),
+                    validationLocale
+                }));
+        }
+    });
+    const classifiedErrors = results.flat();
+    const rawErrors = classifiedErrors.map(({ error })=>error);
+    // A non-localized field carries one shared value, so every locale pass validates it
+    // identically and would otherwise report the same failure once per resolved locale.
+    const errors = locales.length > 1 ? dedupeNonLocalizedFieldErrors({
+        errors: classifiedErrors,
+        localeCount: locales.length
+    }) : rawErrors;
+    return {
+        errors,
+        valid: errors.length === 0
+    };
+}
+function dedupeNonLocalizedFieldErrors({ errors, localeCount }) {
+    const localesByErrorIdentity = new Map();
+    const seenNonLocalizedErrors = new Set();
+    const deduped = [];
+    for (const { error, isLocalized, validationLocale } of errors){
+        if (!isLocalized) {
+            const errorIdentity = JSON.stringify([
+                error.path,
+                error.message
+            ]);
+            const validationLocales = localesByErrorIdentity.get(errorIdentity) ?? new Set();
+            validationLocales.add(validationLocale);
+            localesByErrorIdentity.set(errorIdentity, validationLocales);
+        }
+    }
+    for (const { error, isLocalized } of errors){
+        if (isLocalized) {
+            deduped.push(error);
+            continue;
+        }
+        const errorIdentity = JSON.stringify([
+            error.path,
+            error.message
+        ]);
+        const hasFailedForEveryLocale = localesByErrorIdentity.get(errorIdentity)?.size === localeCount;
+        if (!hasFailedForEveryLocale) {
+            deduped.push(error);
+            continue;
+        }
+        if (seenNonLocalizedErrors.has(errorIdentity)) {
+            continue;
+        }
+        seenNonLocalizedErrors.add(errorIdentity);
+        deduped.push({
+            ...error,
+            locale: undefined
+        });
+    }
+    return deduped;
+}
+
+//# sourceMappingURL=runLocaleScopedValidation.js.map

package/dist/utilities/runLocaleScopedValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/runLocaleScopedValidation.ts"],"sourcesContent":["import type { ValidationFieldError } from '../errors/index.js'\nimport type { Field } from '../fields/config/types.js'\nimport type { Payload, RequestContext, User } from '../index.js'\nimport type { JsonObject, PayloadRequest } from '../types/index.js'\nimport type { ValidationResult } from '../types/validation.js'\n\nimport {\n  cloneValidationContext,\n  cloneValidationData,\n  cloneValidationRequest,\n  cloneValidationUser,\n} from './cloneValidationRequest.js'\nimport { createPayloadRequest } from './createPayloadRequest.js'\nimport { flattenDataByLocale } from './flattenDataByLocale.js'\nimport { isValidationErrorPathLocalized } from './isValidationErrorPathLocalized.js'\nimport {\n  resolveValidationConcurrency,\n  resolveValidationLocales,\n  runValidationLocalePasses,\n  type ValidationLocaleSelector,\n} from './resolveValidationLocales.js'\n\ntype ClassifiedValidationError = {\n  error: ValidationFieldError\n  isLocalized: boolean\n  validationLocale: null | string\n}\n\n/**\n * Clones the caller's request, scopes it to the requested operation, resolves the selected locales, runs\n * `runPass` once per locale against an independent request/data clone, and aggregates the field\n * errors. Shared by the collection and global local validate wrappers so the locale-cloning and\n * pass-running plumbing has one owner instead of two copies that can drift apart.\n */\nexport async function runLocaleScopedValidation<TData>({\n  context,\n  data,\n  dataIsLocaleKeyed = false,\n  fields,\n  locale,\n  operation = 'validate',\n  payload,\n  req,\n  runPass,\n  user,\n}: {\n  context: RequestContext | undefined\n  data: TData\n  dataIsLocaleKeyed?: boolean\n  fields: Field[]\n  locale: undefined | ValidationLocaleSelector\n  operation?: 'create' | 'update' | 'validate'\n  payload: Payload\n  req: Partial<PayloadRequest> | undefined\n  runPass: (args: {\n    data: TData\n    onValidationData: (data: JsonObject) => void\n    req: PayloadRequest\n  }) => Promise<ValidationResult>\n  user: null | undefined | User\n}): Promise<ValidationResult> {\n  const baseReq = await createPayloadRequest({\n    context: cloneValidationContext({ context }),\n    fallbackLocale: false,\n    payload,\n    req: cloneValidationRequest({ request: req }),\n    user: cloneValidationUser({ user }),\n  })\n  baseReq.operation = operation\n  const localeSelector = locale === undefined ? (baseReq.locale ?? null) : locale\n  const locales = await resolveValidationLocales({\n    locale: localeSelector,\n    req: baseReq,\n  })\n  const results = await runValidationLocalePasses({\n    concurrency: resolveValidationConcurrency(req),\n    locales,\n    validate: async (validationLocale) => {\n      const localeReq = await createPayloadRequest({\n        fallbackLocale: false,\n        locale: validationLocale ?? undefined,\n        payload,\n        req: cloneValidationRequest({ request: baseReq }),\n      })\n      const validationCandidateData = cloneValidationData({ data })\n      const validationData =\n        dataIsLocaleKeyed && validationLocale\n          ? (flattenDataByLocale({\n              configBlockReferences: payload.config.blocks,\n              docWithLocales: validationCandidateData as JsonObject,\n              fields,\n              locale: validationLocale,\n            }) as TData)\n          : validationCandidateData\n\n      let mergedValidationData = validationData as JsonObject\n      const result = await runPass({\n        data: validationData,\n        onValidationData: (mergedData) => {\n          mergedValidationData = mergedData\n        },\n        req: localeReq,\n      })\n\n      return result.errors.map((error) => ({\n        error,\n        isLocalized: isValidationErrorPathLocalized({\n          configBlockReferences: payload.config.blocks,\n          data: mergedValidationData,\n          fields,\n          path: error.path,\n        }),\n        validationLocale,\n      }))\n    },\n  })\n  const classifiedErrors = results.flat()\n  const rawErrors = classifiedErrors.map(({ error }) => error)\n\n  // A non-localized field carries one shared value, so every locale pass validates it\n  // identically and would otherwise report the same failure once per resolved locale.\n  const errors =\n    locales.length > 1\n      ? dedupeNonLocalizedFieldErrors({\n          errors: classifiedErrors,\n          localeCount: locales.length,\n        })\n      : rawErrors\n\n  return {\n    errors,\n    valid: errors.length === 0,\n  }\n}\n\nfunction dedupeNonLocalizedFieldErrors({\n  errors,\n  localeCount,\n}: {\n  errors: ClassifiedValidationError[]\n  localeCount: number\n}): ValidationFieldError[] {\n  const localesByErrorIdentity = new Map<string, Set<null | string>>()\n  const seenNonLocalizedErrors = new Set<string>()\n  const deduped: ValidationFieldError[] = []\n\n  for (const { error, isLocalized, validationLocale } of errors) {\n    if (!isLocalized) {\n      const errorIdentity = JSON.stringify([error.path, error.message])\n      const validationLocales = localesByErrorIdentity.get(errorIdentity) ?? new Set()\n\n      validationLocales.add(validationLocale)\n      localesByErrorIdentity.set(errorIdentity, validationLocales)\n    }\n  }\n\n  for (const { error, isLocalized } of errors) {\n    if (isLocalized) {\n      deduped.push(error)\n      continue\n    }\n\n    const errorIdentity = JSON.stringify([error.path, error.message])\n    const hasFailedForEveryLocale = localesByErrorIdentity.get(errorIdentity)?.size === localeCount\n\n    if (!hasFailedForEveryLocale) {\n      deduped.push(error)\n      continue\n    }\n\n    if (seenNonLocalizedErrors.has(errorIdentity)) {\n      continue\n    }\n\n    seenNonLocalizedErrors.add(errorIdentity)\n    deduped.push({ ...error, locale: undefined })\n  }\n\n  return deduped\n}\n"],"names":["cloneValidationContext","cloneValidationData","cloneValidationRequest","cloneValidationUser","createPayloadRequest","flattenDataByLocale","isValidationErrorPathLocalized","resolveValidationConcurrency","resolveValidationLocales","runValidationLocalePasses","runLocaleScopedValidation","context","data","dataIsLocaleKeyed","fields","locale","operation","payload","req","runPass","user","baseReq","fallbackLocale","request","localeSelector","undefined","locales","results","concurrency","validate","validationLocale","localeReq","validationCandidateData","validationData","configBlockReferences","config","blocks","docWithLocales","mergedValidationData","result","onValidationData","mergedData","errors","map","error","isLocalized","path","classifiedErrors","flat","rawErrors","length","dedupeNonLocalizedFieldErrors","localeCount","valid","localesByErrorIdentity","Map","seenNonLocalizedErrors","Set","deduped","errorIdentity","JSON","stringify","message","validationLocales","get","add","set","push","hasFailedForEveryLocale","size","has"],"mappings":"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"}

package/dist/utilities/runValidationLifecycle.d.ts

@@ -0,0 +1,41 @@
+import type { SanitizedCollectionConfig } from '../collections/config/types.js';
+import type { SanitizedGlobalConfig } from '../globals/config/types.js';
+import type { JsonObject, PayloadRequest } from '../types/index.js';
+import type { ValidationResult } from '../types/validation.js';
+type EntityArgs = {
+    collection: null;
+    global: SanitizedGlobalConfig;
+    id?: never;
+} | {
+    collection: SanitizedCollectionConfig;
+    global: null;
+    id?: number | string;
+};
+export type ValidationSourceData = {
+    docWithLocales: JsonObject;
+    originalDoc: JsonObject;
+    originalLocale: string;
+};
+type RunValidationLifecycleArgs = {
+    beforeValidation?: (args: {
+        data: JsonObject;
+    }) => Promise<void> | void;
+    docWithLocales: JsonObject;
+    incomingData: JsonObject | undefined;
+    onValidationData?: (data: JsonObject) => void;
+    originalDoc: JsonObject;
+    overrideAccess: boolean;
+    req: PayloadRequest;
+    skipMutationHooks?: boolean;
+    validateData?: (args: {
+        data: JsonObject;
+    }) => Promise<void> | void;
+    validationOperation?: 'create' | 'update' | 'validate';
+} & EntityArgs;
+/**
+ * Runs the hook and field-validation lifecycle shared by collection and global on-demand
+ * validation after the operation has loaded its source document.
+ */
+export declare function runValidationLifecycle(args: RunValidationLifecycleArgs): Promise<ValidationResult>;
+export {};
+//# sourceMappingURL=runValidationLifecycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runValidationLifecycle.d.ts","sourceRoot":"","sources":["../../src/utilities/runValidationLifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAQ9D,KAAK,UAAU,GACX;IACE,UAAU,EAAE,IAAI,CAAA;IAChB,MAAM,EAAE,qBAAqB,CAAA;IAC7B,EAAE,CAAC,EAAE,KAAK,CAAA;CACX,GACD;IACE,UAAU,EAAE,yBAAyB,CAAA;IACrC,MAAM,EAAE,IAAI,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CACrB,CAAA;AAEL,MAAM,MAAM,oBAAoB,GAAG;IACjC,cAAc,EAAE,UAAU,CAAA;IAC1B,WAAW,EAAE,UAAU,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,KAAK,0BAA0B,GAAG;IAChC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACvE,cAAc,EAAE,UAAU,CAAA;IAC1B,YAAY,EAAE,UAAU,GAAG,SAAS,CAAA;IACpC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IAC7C,WAAW,EAAE,UAAU,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACnE,mBAAmB,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAA;CACvD,GAAG,UAAU,CAAA;AAEd;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CAiI3B"}

package/dist/utilities/runValidationLifecycle.js

@@ -0,0 +1,118 @@
+import { beforeChange } from '../fields/hooks/beforeChange/index.js';
+import { beforeValidate } from '../fields/hooks/beforeValidate/index.js';
+import { deepCopyObjectSimple } from './deepCopyObject.js';
+import { deepMergeWithSourceArraysIgnoringUndefined } from './deepMerge.js';
+import { toValidationResult } from './toValidationResult.js';
+/**
+ * Runs the hook and field-validation lifecycle shared by collection and global on-demand
+ * validation after the operation has loaded its source document.
+ */ export async function runValidationLifecycle(args) {
+    const { id, beforeValidation, collection, docWithLocales, global, incomingData, onValidationData, originalDoc, overrideAccess, req, skipMutationHooks = false, validateData, validationOperation = 'validate' } = args;
+    let data = deepCopyObjectSimple(incomingData ?? {});
+    try {
+        onValidationData?.(deepMergeWithSourceArraysIgnoringUndefined(originalDoc, data));
+        if (!skipMutationHooks) {
+            await beforeValidation?.({
+                data
+            });
+            data = await beforeValidate({
+                id,
+                collection,
+                context: req.context,
+                data,
+                doc: originalDoc,
+                global,
+                operation: validationOperation,
+                overrideAccess,
+                req
+            });
+            onValidationData?.(data);
+            if (collection) {
+                for (const hook of collection.hooks.beforeValidate ?? []){
+                    data = await hook({
+                        collection,
+                        context: req.context,
+                        data,
+                        operation: validationOperation,
+                        originalDoc,
+                        req
+                    }) || data;
+                }
+                for (const hook of collection.hooks.beforeChange ?? []){
+                    data = await hook({
+                        collection,
+                        context: req.context,
+                        data,
+                        operation: validationOperation,
+                        originalDoc,
+                        req
+                    }) || data;
+                }
+            } else {
+                if (validationOperation === 'create') {
+                    throw new Error('Global validation does not support the create operation.');
+                }
+                for (const hook of global.hooks.beforeValidate ?? []){
+                    data = await hook({
+                        context: req.context,
+                        data,
+                        global,
+                        operation: validationOperation,
+                        originalDoc,
+                        overrideAccess,
+                        req
+                    }) || data;
+                }
+                for (const hook of global.hooks.beforeChange ?? []){
+                    data = await hook({
+                        context: req.context,
+                        data,
+                        global,
+                        operation: validationOperation,
+                        originalDoc,
+                        overrideAccess,
+                        req
+                    }) || data;
+                }
+            }
+            onValidationData?.(data);
+        }
+        let processedData = data;
+        await beforeChange({
+            id,
+            collection,
+            context: req.context,
+            data: id === undefined ? data : {
+                ...data,
+                id
+            },
+            doc: originalDoc,
+            docWithLocales,
+            global,
+            isValidationOperation: true,
+            onDataProcessed: (result)=>{
+                processedData = deepCopyObjectSimple(result);
+            },
+            operation: validationOperation,
+            overrideAccess,
+            req,
+            skipHooks: skipMutationHooks
+        });
+        const validationData = deepMergeWithSourceArraysIgnoringUndefined(originalDoc, processedData);
+        onValidationData?.(validationData);
+        await validateData?.({
+            data: validationData
+        });
+    } catch (error) {
+        return toValidationResult({
+            error,
+            req
+        });
+    }
+    return {
+        errors: [],
+        valid: true
+    };
+}
+
+//# sourceMappingURL=runValidationLifecycle.js.map

package/dist/utilities/runValidationLifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/runValidationLifecycle.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../collections/config/types.js'\nimport type { SanitizedGlobalConfig } from '../globals/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../types/index.js'\nimport type { ValidationResult } from '../types/validation.js'\n\nimport { beforeChange } from '../fields/hooks/beforeChange/index.js'\nimport { beforeValidate } from '../fields/hooks/beforeValidate/index.js'\nimport { deepCopyObjectSimple } from './deepCopyObject.js'\nimport { deepMergeWithSourceArraysIgnoringUndefined } from './deepMerge.js'\nimport { toValidationResult } from './toValidationResult.js'\n\ntype EntityArgs =\n  | {\n      collection: null\n      global: SanitizedGlobalConfig\n      id?: never\n    }\n  | {\n      collection: SanitizedCollectionConfig\n      global: null\n      id?: number | string\n    }\n\nexport type ValidationSourceData = {\n  docWithLocales: JsonObject\n  originalDoc: JsonObject\n  originalLocale: string\n}\n\ntype RunValidationLifecycleArgs = {\n  beforeValidation?: (args: { data: JsonObject }) => Promise<void> | void\n  docWithLocales: JsonObject\n  incomingData: JsonObject | undefined\n  onValidationData?: (data: JsonObject) => void\n  originalDoc: JsonObject\n  overrideAccess: boolean\n  req: PayloadRequest\n  skipMutationHooks?: boolean\n  validateData?: (args: { data: JsonObject }) => Promise<void> | void\n  validationOperation?: 'create' | 'update' | 'validate'\n} & EntityArgs\n\n/**\n * Runs the hook and field-validation lifecycle shared by collection and global on-demand\n * validation after the operation has loaded its source document.\n */\nexport async function runValidationLifecycle(\n  args: RunValidationLifecycleArgs,\n): Promise<ValidationResult> {\n  const {\n    id,\n    beforeValidation,\n    collection,\n    docWithLocales,\n    global,\n    incomingData,\n    onValidationData,\n    originalDoc,\n    overrideAccess,\n    req,\n    skipMutationHooks = false,\n    validateData,\n    validationOperation = 'validate',\n  } = args\n  let data = deepCopyObjectSimple(incomingData ?? {})\n\n  try {\n    onValidationData?.(deepMergeWithSourceArraysIgnoringUndefined<JsonObject>(originalDoc, data))\n    if (!skipMutationHooks) {\n      await beforeValidation?.({ data })\n\n      data = await beforeValidate({\n        id,\n        collection,\n        context: req.context,\n        data,\n        doc: originalDoc,\n        global,\n        operation: validationOperation,\n        overrideAccess,\n        req,\n      })\n      onValidationData?.(data)\n\n      if (collection) {\n        for (const hook of collection.hooks.beforeValidate ?? []) {\n          data =\n            (await hook({\n              collection,\n              context: req.context,\n              data,\n              operation: validationOperation,\n              originalDoc,\n              req,\n            })) || data\n        }\n\n        for (const hook of collection.hooks.beforeChange ?? []) {\n          data =\n            (await hook({\n              collection,\n              context: req.context,\n              data,\n              operation: validationOperation,\n              originalDoc,\n              req,\n            })) || data\n        }\n      } else {\n        if (validationOperation === 'create') {\n          throw new Error('Global validation does not support the create operation.')\n        }\n\n        for (const hook of global.hooks.beforeValidate ?? []) {\n          data =\n            (await hook({\n              context: req.context,\n              data,\n              global,\n              operation: validationOperation,\n              originalDoc,\n              overrideAccess,\n              req,\n            })) || data\n        }\n\n        for (const hook of global.hooks.beforeChange ?? []) {\n          data =\n            (await hook({\n              context: req.context,\n              data,\n              global,\n              operation: validationOperation,\n              originalDoc,\n              overrideAccess,\n              req,\n            })) || data\n        }\n      }\n\n      onValidationData?.(data)\n    }\n\n    let processedData = data\n\n    await beforeChange({\n      id,\n      collection,\n      context: req.context,\n      data: id === undefined ? data : { ...data, id },\n      doc: originalDoc,\n      docWithLocales,\n      global,\n      isValidationOperation: true,\n      onDataProcessed: (result) => {\n        processedData = deepCopyObjectSimple(result)\n      },\n      operation: validationOperation,\n      overrideAccess,\n      req,\n      skipHooks: skipMutationHooks,\n    })\n\n    const validationData = deepMergeWithSourceArraysIgnoringUndefined<JsonObject>(\n      originalDoc,\n      processedData,\n    )\n    onValidationData?.(validationData)\n    await validateData?.({ data: validationData })\n  } catch (error) {\n    return toValidationResult({ error, req })\n  }\n\n  return {\n    errors: [],\n    valid: true,\n  }\n}\n"],"names":["beforeChange","beforeValidate","deepCopyObjectSimple","deepMergeWithSourceArraysIgnoringUndefined","toValidationResult","runValidationLifecycle","args","id","beforeValidation","collection","docWithLocales","global","incomingData","onValidationData","originalDoc","overrideAccess","req","skipMutationHooks","validateData","validationOperation","data","context","doc","operation","hook","hooks","Error","processedData","undefined","isValidationOperation","onDataProcessed","result","skipHooks","validationData","error","errors","valid"],"mappings":"AAKA,SAASA,YAAY,QAAQ,wCAAuC;AACpE,SAASC,cAAc,QAAQ,0CAAyC;AACxE,SAASC,oBAAoB,QAAQ,sBAAqB;AAC1D,SAASC,0CAA0C,QAAQ,iBAAgB;AAC3E,SAASC,kBAAkB,QAAQ,0BAAyB;AAiC5D;;;CAGC,GACD,OAAO,eAAeC,uBACpBC,IAAgC;IAEhC,MAAM,EACJC,EAAE,EACFC,gBAAgB,EAChBC,UAAU,EACVC,cAAc,EACdC,MAAM,EACNC,YAAY,EACZC,gBAAgB,EAChBC,WAAW,EACXC,cAAc,EACdC,GAAG,EACHC,oBAAoB,KAAK,EACzBC,YAAY,EACZC,sBAAsB,UAAU,EACjC,GAAGb;IACJ,IAAIc,OAAOlB,qBAAqBU,gBAAgB,CAAC;IAEjD,IAAI;QACFC,mBAAmBV,2CAAuDW,aAAaM;QACvF,IAAI,CAACH,mBAAmB;YACtB,MAAMT,mBAAmB;gBAAEY;YAAK;YAEhCA,OAAO,MAAMnB,eAAe;gBAC1BM;gBACAE;gBACAY,SAASL,IAAIK,OAAO;gBACpBD;gBACAE,KAAKR;gBACLH;gBACAY,WAAWJ;gBACXJ;gBACAC;YACF;YACAH,mBAAmBO;YAEnB,IAAIX,YAAY;gBACd,KAAK,MAAMe,QAAQf,WAAWgB,KAAK,CAACxB,cAAc,IAAI,EAAE,CAAE;oBACxDmB,OACE,AAAC,MAAMI,KAAK;wBACVf;wBACAY,SAASL,IAAIK,OAAO;wBACpBD;wBACAG,WAAWJ;wBACXL;wBACAE;oBACF,MAAOI;gBACX;gBAEA,KAAK,MAAMI,QAAQf,WAAWgB,KAAK,CAACzB,YAAY,IAAI,EAAE,CAAE;oBACtDoB,OACE,AAAC,MAAMI,KAAK;wBACVf;wBACAY,SAASL,IAAIK,OAAO;wBACpBD;wBACAG,WAAWJ;wBACXL;wBACAE;oBACF,MAAOI;gBACX;YACF,OAAO;gBACL,IAAID,wBAAwB,UAAU;oBACpC,MAAM,IAAIO,MAAM;gBAClB;gBAEA,KAAK,MAAMF,QAAQb,OAAOc,KAAK,CAACxB,cAAc,IAAI,EAAE,CAAE;oBACpDmB,OACE,AAAC,MAAMI,KAAK;wBACVH,SAASL,IAAIK,OAAO;wBACpBD;wBACAT;wBACAY,WAAWJ;wBACXL;wBACAC;wBACAC;oBACF,MAAOI;gBACX;gBAEA,KAAK,MAAMI,QAAQb,OAAOc,KAAK,CAACzB,YAAY,IAAI,EAAE,CAAE;oBAClDoB,OACE,AAAC,MAAMI,KAAK;wBACVH,SAASL,IAAIK,OAAO;wBACpBD;wBACAT;wBACAY,WAAWJ;wBACXL;wBACAC;wBACAC;oBACF,MAAOI;gBACX;YACF;YAEAP,mBAAmBO;QACrB;QAEA,IAAIO,gBAAgBP;QAEpB,MAAMpB,aAAa;YACjBO;YACAE;YACAY,SAASL,IAAIK,OAAO;YACpBD,MAAMb,OAAOqB,YAAYR,OAAO;gBAAE,GAAGA,IAAI;gBAAEb;YAAG;YAC9Ce,KAAKR;YACLJ;YACAC;YACAkB,uBAAuB;YACvBC,iBAAiB,CAACC;gBAChBJ,gBAAgBzB,qBAAqB6B;YACvC;YACAR,WAAWJ;YACXJ;YACAC;YACAgB,WAAWf;QACb;QAEA,MAAMgB,iBAAiB9B,2CACrBW,aACAa;QAEFd,mBAAmBoB;QACnB,MAAMf,eAAe;YAAEE,MAAMa;QAAe;IAC9C,EAAE,OAAOC,OAAO;QACd,OAAO9B,mBAAmB;YAAE8B;YAAOlB;QAAI;IACzC;IAEA,OAAO;QACLmB,QAAQ,EAAE;QACVC,OAAO;IACT;AACF"}

package/dist/utilities/sanitizeUploadPrefix.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Normalizes a storage prefix to the canonical path used by upload adapters.
+ */
+export declare function sanitizeUploadPrefix(prefix: string): string;
+//# sourceMappingURL=sanitizeUploadPrefix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeUploadPrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/sanitizeUploadPrefix.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAuB3D"}

package/dist/utilities/sanitizeUploadPrefix.js

@@ -0,0 +1,18 @@
+/**
+ * Normalizes a storage prefix to the canonical path used by upload adapters.
+ */ export function sanitizeUploadPrefix(prefix) {
+    let decodedPrefix;
+    try {
+        decodedPrefix = decodeURIComponent(prefix);
+    } catch  {
+        return '';
+    }
+    // Reject multi-encoded values (e.g. `%252f`) by allowing only one decode pass.
+    if (/%[0-9a-f]{2}/i.test(decodedPrefix)) {
+        return '';
+    }
+    return decodedPrefix.replace(/\\/g, '/')// eslint-disable-next-line no-control-regex
+    .replace(/[\x00-\x1f\x80-\x9f]/g, '').split('/').filter((segment)=>segment && segment !== '..' && segment !== '.').join('/');
+}
+
+//# sourceMappingURL=sanitizeUploadPrefix.js.map

package/dist/utilities/sanitizeUploadPrefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/sanitizeUploadPrefix.ts"],"sourcesContent":["/**\n * Normalizes a storage prefix to the canonical path used by upload adapters.\n */\nexport function sanitizeUploadPrefix(prefix: string): string {\n  let decodedPrefix: string\n\n  try {\n    decodedPrefix = decodeURIComponent(prefix)\n  } catch {\n    return ''\n  }\n\n  // Reject multi-encoded values (e.g. `%252f`) by allowing only one decode pass.\n  if (/%[0-9a-f]{2}/i.test(decodedPrefix)) {\n    return ''\n  }\n\n  return (\n    decodedPrefix\n      .replace(/\\\\/g, '/')\n      // eslint-disable-next-line no-control-regex\n      .replace(/[\\x00-\\x1f\\x80-\\x9f]/g, '')\n      .split('/')\n      .filter((segment) => segment && segment !== '..' && segment !== '.')\n      .join('/')\n  )\n}\n"],"names":["sanitizeUploadPrefix","prefix","decodedPrefix","decodeURIComponent","test","replace","split","filter","segment","join"],"mappings":"AAAA;;CAEC,GACD,OAAO,SAASA,qBAAqBC,MAAc;IACjD,IAAIC;IAEJ,IAAI;QACFA,gBAAgBC,mBAAmBF;IACrC,EAAE,OAAM;QACN,OAAO;IACT;IAEA,+EAA+E;IAC/E,IAAI,gBAAgBG,IAAI,CAACF,gBAAgB;QACvC,OAAO;IACT;IAEA,OACEA,cACGG,OAAO,CAAC,OAAO,IAChB,4CAA4C;KAC3CA,OAAO,CAAC,yBAAyB,IACjCC,KAAK,CAAC,KACNC,MAAM,CAAC,CAACC,UAAYA,WAAWA,YAAY,QAAQA,YAAY,KAC/DC,IAAI,CAAC;AAEZ"}