@depup/payload 3.79.1-depup.0

package/dist/utilities/headersWithCors.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadRequest } from '../types/index.js';
+type CorsArgs = {
+    headers: Headers;
+    req: Partial<PayloadRequest>;
+};
+export declare const headersWithCors: ({ headers, req }: CorsArgs) => Headers;
+export {};
+//# sourceMappingURL=headersWithCors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headersWithCors.d.ts","sourceRoot":"","sources":["../../src/utilities/headersWithCors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,qBAAsB,QAAQ,KAAG,OAiD5D,CAAA"}

package/dist/utilities/headersWithCors.js

@@ -0,0 +1,41 @@
+export const headersWithCors = ({ headers, req })=>{
+    const cors = req?.payload?.config.cors;
+    const requestOrigin = req?.headers?.get('Origin');
+    if (cors) {
+        const defaultAllowedHeaders = [
+            'Origin',
+            'X-Requested-With',
+            'Content-Type',
+            'Accept',
+            'Authorization',
+            'Content-Encoding',
+            'x-apollo-tracing',
+            'X-Payload-HTTP-Method-Override'
+        ];
+        // Only set default CORS headers if they haven't been set by custom handler
+        if (!headers.has('Access-Control-Allow-Methods')) {
+            headers.set('Access-Control-Allow-Methods', 'PUT, PATCH, POST, GET, DELETE, OPTIONS');
+        }
+        if (!headers.has('Access-Control-Allow-Headers')) {
+            if (typeof cors === 'object' && 'headers' in cors) {
+                headers.set('Access-Control-Allow-Headers', [
+                    ...defaultAllowedHeaders,
+                    ...cors.headers
+                ].filter(Boolean).join(', '));
+            } else {
+                headers.set('Access-Control-Allow-Headers', defaultAllowedHeaders.join(', '));
+            }
+        }
+        if (!headers.has('Access-Control-Allow-Origin')) {
+            if (cors === '*' || typeof cors === 'object' && 'origins' in cors && cors.origins === '*') {
+                headers.set('Access-Control-Allow-Origin', '*');
+            } else if (Array.isArray(cors) && cors.indexOf(requestOrigin) > -1 || !Array.isArray(cors) && typeof cors === 'object' && 'origins' in cors && cors.origins.indexOf(requestOrigin) > -1) {
+                headers.set('Access-Control-Allow-Credentials', 'true');
+                headers.set('Access-Control-Allow-Origin', requestOrigin);
+            }
+        }
+    }
+    return headers;
+};
+
+//# sourceMappingURL=headersWithCors.js.map

package/dist/utilities/headersWithCors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/headersWithCors.ts"],"sourcesContent":["import type { PayloadRequest } from '../types/index.js'\n\ntype CorsArgs = {\n  headers: Headers\n  req: Partial<PayloadRequest>\n}\nexport const headersWithCors = ({ headers, req }: CorsArgs): Headers => {\n  const cors = req?.payload?.config.cors\n  const requestOrigin = req?.headers?.get('Origin')\n\n  if (cors) {\n    const defaultAllowedHeaders = [\n      'Origin',\n      'X-Requested-With',\n      'Content-Type',\n      'Accept',\n      'Authorization',\n      'Content-Encoding',\n      'x-apollo-tracing',\n      'X-Payload-HTTP-Method-Override',\n    ]\n\n    // Only set default CORS headers if they haven't been set by custom handler\n    if (!headers.has('Access-Control-Allow-Methods')) {\n      headers.set('Access-Control-Allow-Methods', 'PUT, PATCH, POST, GET, DELETE, OPTIONS')\n    }\n\n    if (!headers.has('Access-Control-Allow-Headers')) {\n      if (typeof cors === 'object' && 'headers' in cors) {\n        headers.set(\n          'Access-Control-Allow-Headers',\n          [...defaultAllowedHeaders, ...cors.headers].filter(Boolean).join(', '),\n        )\n      } else {\n        headers.set('Access-Control-Allow-Headers', defaultAllowedHeaders.join(', '))\n      }\n    }\n\n    if (!headers.has('Access-Control-Allow-Origin')) {\n      if (cors === '*' || (typeof cors === 'object' && 'origins' in cors && cors.origins === '*')) {\n        headers.set('Access-Control-Allow-Origin', '*')\n      } else if (\n        (Array.isArray(cors) && cors.indexOf(requestOrigin!) > -1) ||\n        (!Array.isArray(cors) &&\n          typeof cors === 'object' &&\n          'origins' in cors &&\n          cors.origins.indexOf(requestOrigin!) > -1)\n      ) {\n        headers.set('Access-Control-Allow-Credentials', 'true')\n        headers.set('Access-Control-Allow-Origin', requestOrigin!)\n      }\n    }\n  }\n\n  return headers\n}\n"],"names":["headersWithCors","headers","req","cors","payload","config","requestOrigin","get","defaultAllowedHeaders","has","set","filter","Boolean","join","origins","Array","isArray","indexOf"],"mappings":"AAMA,OAAO,MAAMA,kBAAkB,CAAC,EAAEC,OAAO,EAAEC,GAAG,EAAY;IACxD,MAAMC,OAAOD,KAAKE,SAASC,OAAOF;IAClC,MAAMG,gBAAgBJ,KAAKD,SAASM,IAAI;IAExC,IAAIJ,MAAM;QACR,MAAMK,wBAAwB;YAC5B;YACA;YACA;YACA;YACA;YACA;YACA;YACA;SACD;QAED,2EAA2E;QAC3E,IAAI,CAACP,QAAQQ,GAAG,CAAC,iCAAiC;YAChDR,QAAQS,GAAG,CAAC,gCAAgC;QAC9C;QAEA,IAAI,CAACT,QAAQQ,GAAG,CAAC,iCAAiC;YAChD,IAAI,OAAON,SAAS,YAAY,aAAaA,MAAM;gBACjDF,QAAQS,GAAG,CACT,gCACA;uBAAIF;uBAA0BL,KAAKF,OAAO;iBAAC,CAACU,MAAM,CAACC,SAASC,IAAI,CAAC;YAErE,OAAO;gBACLZ,QAAQS,GAAG,CAAC,gCAAgCF,sBAAsBK,IAAI,CAAC;YACzE;QACF;QAEA,IAAI,CAACZ,QAAQQ,GAAG,CAAC,gCAAgC;YAC/C,IAAIN,SAAS,OAAQ,OAAOA,SAAS,YAAY,aAAaA,QAAQA,KAAKW,OAAO,KAAK,KAAM;gBAC3Fb,QAAQS,GAAG,CAAC,+BAA+B;YAC7C,OAAO,IACL,AAACK,MAAMC,OAAO,CAACb,SAASA,KAAKc,OAAO,CAACX,iBAAkB,CAAC,KACvD,CAACS,MAAMC,OAAO,CAACb,SACd,OAAOA,SAAS,YAChB,aAAaA,QACbA,KAAKW,OAAO,CAACG,OAAO,CAACX,iBAAkB,CAAC,GAC1C;gBACAL,QAAQS,GAAG,CAAC,oCAAoC;gBAChDT,QAAQS,GAAG,CAAC,+BAA+BJ;YAC7C;QACF;IACF;IAEA,OAAOL;AACT,EAAC"}

package/dist/utilities/initTransaction.d.ts

@@ -0,0 +1,8 @@
+import type { MarkRequired } from 'ts-essentials';
+import type { PayloadRequest } from '../types/index.js';
+/**
+ * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction
+ * @returns true if beginning a transaction and false when req already has a transaction to use
+ */
+export declare function initTransaction(req: MarkRequired<Partial<PayloadRequest>, 'payload'>): Promise<boolean>;
+//# sourceMappingURL=initTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/initTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,OAAO,CAAC,CAwBlB"}

package/dist/utilities/initTransaction.js

@@ -0,0 +1,28 @@
+/**
+ * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction
+ * @returns true if beginning a transaction and false when req already has a transaction to use
+ */ export async function initTransaction(req) {
+    const { payload, transactionID } = req;
+    if (transactionID instanceof Promise) {
+        // wait for whoever else is already creating the transaction
+        await transactionID;
+        return false;
+    }
+    if (transactionID) {
+        // we already have a transaction, we're not in charge of committing it
+        return false;
+    }
+    if (typeof payload.db.beginTransaction === 'function') {
+        // create a new transaction
+        req.transactionID = payload.db.beginTransaction().then((transactionID)=>{
+            if (transactionID) {
+                req.transactionID = transactionID;
+            }
+            return transactionID;
+        });
+        return !!await req.transactionID;
+    }
+    return false;
+}
+
+//# sourceMappingURL=initTransaction.js.map

package/dist/utilities/initTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/initTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\n/**\n * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction\n * @returns true if beginning a transaction and false when req already has a transaction to use\n */\nexport async function initTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<boolean> {\n  const { payload, transactionID } = req\n  if (transactionID instanceof Promise) {\n    // wait for whoever else is already creating the transaction\n    await transactionID\n    return false\n  }\n\n  if (transactionID) {\n    // we already have a transaction, we're not in charge of committing it\n    return false\n  }\n  if (typeof payload.db.beginTransaction === 'function') {\n    // create a new transaction\n    req.transactionID = payload.db.beginTransaction().then((transactionID) => {\n      if (transactionID) {\n        req.transactionID = transactionID\n      }\n\n      return transactionID!\n    })\n    return !!(await req.transactionID)\n  }\n  return false\n}\n"],"names":["initTransaction","req","payload","transactionID","Promise","db","beginTransaction","then"],"mappings":"AAIA;;;CAGC,GACD,OAAO,eAAeA,gBACpBC,GAAqD;IAErD,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGF;IACnC,IAAIE,yBAAyBC,SAAS;QACpC,4DAA4D;QAC5D,MAAMD;QACN,OAAO;IACT;IAEA,IAAIA,eAAe;QACjB,sEAAsE;QACtE,OAAO;IACT;IACA,IAAI,OAAOD,QAAQG,EAAE,CAACC,gBAAgB,KAAK,YAAY;QACrD,2BAA2B;QAC3BL,IAAIE,aAAa,GAAGD,QAAQG,EAAE,CAACC,gBAAgB,GAAGC,IAAI,CAAC,CAACJ;YACtD,IAAIA,eAAe;gBACjBF,IAAIE,aAAa,GAAGA;YACtB;YAEA,OAAOA;QACT;QACA,OAAO,CAAC,CAAE,MAAMF,IAAIE,aAAa;IACnC;IACA,OAAO;AACT"}

package/dist/utilities/isEntityHidden.d.ts

@@ -0,0 +1,8 @@
+import type { SanitizedCollectionConfig } from '../collections/config/types.js';
+import type { SanitizedGlobalConfig } from '../globals/config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+export declare const isEntityHidden: ({ hidden, user, }: {
+    hidden: SanitizedCollectionConfig["admin"]["hidden"] | SanitizedGlobalConfig["admin"]["hidden"];
+    user: PayloadRequest["user"];
+}) => boolean;
+//# sourceMappingURL=isEntityHidden.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isEntityHidden.d.ts","sourceRoot":"","sources":["../../src/utilities/isEntityHidden.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,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,eAAO,MAAM,cAAc,sBAGxB;IACD,MAAM,EAAE,yBAAyB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAA;IAC/F,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAA;CAC7B,YAEA,CAAA"}

package/dist/utilities/isEntityHidden.js

@@ -0,0 +1,7 @@
+export const isEntityHidden = ({ hidden, user })=>{
+    return typeof hidden === 'function' ? hidden({
+        user: user
+    }) : hidden === true;
+};
+
+//# sourceMappingURL=isEntityHidden.js.map

package/dist/utilities/isEntityHidden.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isEntityHidden.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../collections/config/types.js'\nimport type { SanitizedGlobalConfig } from '../globals/config/types.js'\nimport type { PayloadRequest } from '../types/index.js'\n\nexport const isEntityHidden = ({\n  hidden,\n  user,\n}: {\n  hidden: SanitizedCollectionConfig['admin']['hidden'] | SanitizedGlobalConfig['admin']['hidden']\n  user: PayloadRequest['user']\n}) => {\n  return typeof hidden === 'function' ? hidden({ user: user! }) : hidden === true\n}\n"],"names":["isEntityHidden","hidden","user"],"mappings":"AAIA,OAAO,MAAMA,iBAAiB,CAAC,EAC7BC,MAAM,EACNC,IAAI,EAIL;IACC,OAAO,OAAOD,WAAW,aAAaA,OAAO;QAAEC,MAAMA;IAAM,KAAKD,WAAW;AAC7E,EAAC"}

package/dist/utilities/isErrorPublic.d.ts

@@ -0,0 +1,6 @@
+import type { SanitizedConfig } from '../config/types.js';
+/**
+ * Determines if an error should be shown to the user.
+ */
+export declare function isErrorPublic(error: Error, config: SanitizedConfig): boolean;
+//# sourceMappingURL=isErrorPublic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isErrorPublic.d.ts","sourceRoot":"","sources":["../../src/utilities/isErrorPublic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAOzD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,WAiBlE"}

package/dist/utilities/isErrorPublic.js

@@ -0,0 +1,21 @@
+import { status as httpStatus } from 'http-status';
+/**
+ * Determines if an error should be shown to the user.
+ */ export function isErrorPublic(error, config) {
+    const payloadError = error;
+    if (config.debug) {
+        return true;
+    }
+    if (payloadError.isPublic === true) {
+        return true;
+    }
+    if (payloadError.isPublic === false) {
+        return false;
+    }
+    if (payloadError.status && payloadError.status !== httpStatus.INTERNAL_SERVER_ERROR) {
+        return true;
+    }
+    return false;
+}
+
+//# sourceMappingURL=isErrorPublic.js.map

package/dist/utilities/isErrorPublic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isErrorPublic.ts"],"sourcesContent":["import { status as httpStatus } from 'http-status'\n\nimport type { SanitizedConfig } from '../config/types.js'\n\ntype PayloadError = {\n  isPublic?: boolean\n  status?: number\n} & Error\n\n/**\n * Determines if an error should be shown to the user.\n */\nexport function isErrorPublic(error: Error, config: SanitizedConfig) {\n  const payloadError = error as PayloadError\n\n  if (config.debug) {\n    return true\n  }\n  if (payloadError.isPublic === true) {\n    return true\n  }\n  if (payloadError.isPublic === false) {\n    return false\n  }\n  if (payloadError.status && payloadError.status !== httpStatus.INTERNAL_SERVER_ERROR) {\n    return true\n  }\n\n  return false\n}\n"],"names":["status","httpStatus","isErrorPublic","error","config","payloadError","debug","isPublic","INTERNAL_SERVER_ERROR"],"mappings":"AAAA,SAASA,UAAUC,UAAU,QAAQ,cAAa;AASlD;;CAEC,GACD,OAAO,SAASC,cAAcC,KAAY,EAAEC,MAAuB;IACjE,MAAMC,eAAeF;IAErB,IAAIC,OAAOE,KAAK,EAAE;QAChB,OAAO;IACT;IACA,IAAID,aAAaE,QAAQ,KAAK,MAAM;QAClC,OAAO;IACT;IACA,IAAIF,aAAaE,QAAQ,KAAK,OAAO;QACnC,OAAO;IACT;IACA,IAAIF,aAAaL,MAAM,IAAIK,aAAaL,MAAM,KAAKC,WAAWO,qBAAqB,EAAE;QACnF,OAAO;IACT;IAEA,OAAO;AACT"}

package/dist/utilities/isNextBuild.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility function to determine if the code is being executed during the Next.js build process.
+ */
+export declare function isNextBuild(): boolean;
+//# sourceMappingURL=isNextBuild.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNextBuild.d.ts","sourceRoot":"","sources":["../../src/utilities/isNextBuild.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,WAAW,YAK1B"}

package/dist/utilities/isNextBuild.js

@@ -0,0 +1,7 @@
+/**
+ * Utility function to determine if the code is being executed during the Next.js build process.
+ */ export function isNextBuild() {
+    return process.env.NEXT_PHASE === 'phase-production-build' || process.env.npm_lifecycle_event === 'build';
+}
+
+//# sourceMappingURL=isNextBuild.js.map

package/dist/utilities/isNextBuild.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isNextBuild.ts"],"sourcesContent":["/**\n * Utility function to determine if the code is being executed during the Next.js build process.\n */\nexport function isNextBuild() {\n  return (\n    process.env.NEXT_PHASE === 'phase-production-build' ||\n    process.env.npm_lifecycle_event === 'build'\n  )\n}\n"],"names":["isNextBuild","process","env","NEXT_PHASE","npm_lifecycle_event"],"mappings":"AAAA;;CAEC,GACD,OAAO,SAASA;IACd,OACEC,QAAQC,GAAG,CAACC,UAAU,KAAK,4BAC3BF,QAAQC,GAAG,CAACE,mBAAmB,KAAK;AAExC"}

package/dist/utilities/isNumber.d.ts

@@ -0,0 +1,2 @@
+export declare function isNumber(value: unknown): value is number;
+//# sourceMappingURL=isNumber.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isNumber.d.ts","sourceRoot":"","sources":["../../src/utilities/isNumber.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAMxD"}

package/dist/utilities/isNumber.js

@@ -0,0 +1,8 @@
+export function isNumber(value) {
+    if (value === null || value === undefined || typeof value === 'string' && value.trim() === '') {
+        return false;
+    }
+    return !Number.isNaN(Number(value));
+}
+
+//# sourceMappingURL=isNumber.js.map

package/dist/utilities/isNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isNumber.ts"],"sourcesContent":["export function isNumber(value: unknown): value is number {\n  if (value === null || value === undefined || (typeof value === 'string' && value.trim() === '')) {\n    return false\n  }\n\n  return !Number.isNaN(Number(value))\n}\n"],"names":["isNumber","value","undefined","trim","Number","isNaN"],"mappings":"AAAA,OAAO,SAASA,SAASC,KAAc;IACrC,IAAIA,UAAU,QAAQA,UAAUC,aAAc,OAAOD,UAAU,YAAYA,MAAME,IAAI,OAAO,IAAK;QAC/F,OAAO;IACT;IAEA,OAAO,CAACC,OAAOC,KAAK,CAACD,OAAOH;AAC9B"}

package/dist/utilities/isPlainObject.d.ts

@@ -0,0 +1,2 @@
+export declare function isPlainObject(o: any): boolean;
+//# sourceMappingURL=isPlainObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../src/utilities/isPlainObject.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,GAAG,OAAO,CAQ7C"}

package/dist/utilities/isPlainObject.js

@@ -0,0 +1,11 @@
+import { isReactComponentOrFunction } from './isReactComponent.js';
+export function isPlainObject(o) {
+    // Is this a React component?
+    if (isReactComponentOrFunction(o)) {
+        return false;
+    }
+    // from https://github.com/fastify/deepmerge/blob/master/index.js#L77
+    return typeof o === 'object' && o !== null && !(o instanceof RegExp) && !(o instanceof Date);
+}
+
+//# sourceMappingURL=isPlainObject.js.map

package/dist/utilities/isPlainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isPlainObject.ts"],"sourcesContent":["import { isReactComponentOrFunction } from './isReactComponent.js'\n\nexport function isPlainObject(o: any): boolean {\n  // Is this a React component?\n  if (isReactComponentOrFunction(o)) {\n    return false\n  }\n\n  // from https://github.com/fastify/deepmerge/blob/master/index.js#L77\n  return typeof o === 'object' && o !== null && !(o instanceof RegExp) && !(o instanceof Date)\n}\n"],"names":["isReactComponentOrFunction","isPlainObject","o","RegExp","Date"],"mappings":"AAAA,SAASA,0BAA0B,QAAQ,wBAAuB;AAElE,OAAO,SAASC,cAAcC,CAAM;IAClC,6BAA6B;IAC7B,IAAIF,2BAA2BE,IAAI;QACjC,OAAO;IACT;IAEA,qEAAqE;IACrE,OAAO,OAAOA,MAAM,YAAYA,MAAM,QAAQ,CAAEA,CAAAA,aAAaC,MAAK,KAAM,CAAED,CAAAA,aAAaE,IAAG;AAC5F"}

package/dist/utilities/isReactComponent.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare function isReactServerComponentOrFunction<T extends any>(component: any | React.ComponentType): component is T;
+export declare function isReactClientComponent<T extends any>(component: any | React.ComponentType): component is T;
+export declare function isReactComponentOrFunction<T extends any>(component: any | React.ComponentType): component is T;
+//# sourceMappingURL=isReactComponent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isReactComponent.d.ts","sourceRoot":"","sources":["../../src/utilities/isReactComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,GAAG,EAC5D,SAAS,EAAE,GAAG,GAAG,KAAK,CAAC,aAAa,GACnC,SAAS,IAAI,CAAC,CAEhB;AAED,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAClD,SAAS,EAAE,GAAG,GAAG,KAAK,CAAC,aAAa,GACnC,SAAS,IAAI,CAAC,CAEhB;AAED,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EACtD,SAAS,EAAE,GAAG,GAAG,KAAK,CAAC,aAAa,GACnC,SAAS,IAAI,CAAC,CAEhB"}

package/dist/utilities/isReactComponent.js

@@ -0,0 +1,12 @@
+const clientRefSymbol = Symbol.for('react.client.reference');
+export function isReactServerComponentOrFunction(component) {
+    return typeof component === 'function' && component.$$typeof !== clientRefSymbol;
+}
+export function isReactClientComponent(component) {
+    return typeof component === 'function' && component.$$typeof === clientRefSymbol;
+}
+export function isReactComponentOrFunction(component) {
+    return typeof component === 'function';
+}
+
+//# sourceMappingURL=isReactComponent.js.map

package/dist/utilities/isReactComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isReactComponent.ts"],"sourcesContent":["import type React from 'react'\n\nconst clientRefSymbol = Symbol.for('react.client.reference')\n\nexport function isReactServerComponentOrFunction<T extends any>(\n  component: any | React.ComponentType,\n): component is T {\n  return typeof component === 'function' && component.$$typeof !== clientRefSymbol\n}\n\nexport function isReactClientComponent<T extends any>(\n  component: any | React.ComponentType,\n): component is T {\n  return typeof component === 'function' && component.$$typeof === clientRefSymbol\n}\n\nexport function isReactComponentOrFunction<T extends any>(\n  component: any | React.ComponentType,\n): component is T {\n  return typeof component === 'function'\n}\n"],"names":["clientRefSymbol","Symbol","for","isReactServerComponentOrFunction","component","$$typeof","isReactClientComponent","isReactComponentOrFunction"],"mappings":"AAEA,MAAMA,kBAAkBC,OAAOC,GAAG,CAAC;AAEnC,OAAO,SAASC,iCACdC,SAAoC;IAEpC,OAAO,OAAOA,cAAc,cAAcA,UAAUC,QAAQ,KAAKL;AACnE;AAEA,OAAO,SAASM,uBACdF,SAAoC;IAEpC,OAAO,OAAOA,cAAc,cAAcA,UAAUC,QAAQ,KAAKL;AACnE;AAEA,OAAO,SAASO,2BACdH,SAAoC;IAEpC,OAAO,OAAOA,cAAc;AAC9B"}

package/dist/utilities/isURLAllowed.d.ts

@@ -0,0 +1,3 @@
+import type { AllowList } from '../uploads/types.js';
+export declare const isURLAllowed: (url: string, allowList: AllowList) => boolean;
+//# sourceMappingURL=isURLAllowed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isURLAllowed.d.ts","sourceRoot":"","sources":["../../src/utilities/isURLAllowed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD,eAAO,MAAM,YAAY,QAAS,MAAM,aAAa,SAAS,KAAG,OAgChE,CAAA"}

package/dist/utilities/isURLAllowed.js

@@ -0,0 +1,33 @@
+export const isURLAllowed = (url, allowList)=>{
+    try {
+        const parsedUrl = new URL(url);
+        return allowList.some((allowItem)=>{
+            return Object.entries(allowItem).every(([key, value])=>{
+                // Skip undefined or null values
+                if (!value) {
+                    return true;
+                }
+                // Compare protocol with colon
+                if (key === 'protocol') {
+                    return typeof value === 'string' && parsedUrl.protocol === `${value}:`;
+                }
+                if (key === 'pathname') {
+                    // Convert wildcards to a regex
+                    const regexPattern = value.replace(/\*\*/g, '.*') // Match any path
+                    .replace(/\*/g, '[^/]*') // Match any part of a path segment
+                    .replace(/\/$/, '(/)?') // Allow optional trailing slash
+                    ;
+                    const regex = new RegExp(`^${regexPattern}$`);
+                    return regex.test(parsedUrl.pathname);
+                }
+                // Default comparison for all other properties (hostname, port, search)
+                return parsedUrl[key] === value;
+            });
+        });
+    } catch  {
+        return false // If the URL is invalid, deny by default
+        ;
+    }
+};
+
+//# sourceMappingURL=isURLAllowed.js.map

package/dist/utilities/isURLAllowed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isURLAllowed.ts"],"sourcesContent":["import type { AllowList } from '../uploads/types.js'\n\nexport const isURLAllowed = (url: string, allowList: AllowList): boolean => {\n  try {\n    const parsedUrl = new URL(url)\n\n    return allowList.some((allowItem) => {\n      return Object.entries(allowItem).every(([key, value]) => {\n        // Skip undefined or null values\n        if (!value) {\n          return true\n        }\n        // Compare protocol with colon\n        if (key === 'protocol') {\n          return typeof value === 'string' && parsedUrl.protocol === `${value}:`\n        }\n\n        if (key === 'pathname') {\n          // Convert wildcards to a regex\n          const regexPattern = value\n            .replace(/\\*\\*/g, '.*') // Match any path\n            .replace(/\\*/g, '[^/]*') // Match any part of a path segment\n            .replace(/\\/$/, '(/)?') // Allow optional trailing slash\n          const regex = new RegExp(`^${regexPattern}$`)\n          return regex.test(parsedUrl.pathname)\n        }\n\n        // Default comparison for all other properties (hostname, port, search)\n        return parsedUrl[key as keyof URL] === value\n      })\n    })\n  } catch {\n    return false // If the URL is invalid, deny by default\n  }\n}\n"],"names":["isURLAllowed","url","allowList","parsedUrl","URL","some","allowItem","Object","entries","every","key","value","protocol","regexPattern","replace","regex","RegExp","test","pathname"],"mappings":"AAEA,OAAO,MAAMA,eAAe,CAACC,KAAaC;IACxC,IAAI;QACF,MAAMC,YAAY,IAAIC,IAAIH;QAE1B,OAAOC,UAAUG,IAAI,CAAC,CAACC;YACrB,OAAOC,OAAOC,OAAO,CAACF,WAAWG,KAAK,CAAC,CAAC,CAACC,KAAKC,MAAM;gBAClD,gCAAgC;gBAChC,IAAI,CAACA,OAAO;oBACV,OAAO;gBACT;gBACA,8BAA8B;gBAC9B,IAAID,QAAQ,YAAY;oBACtB,OAAO,OAAOC,UAAU,YAAYR,UAAUS,QAAQ,KAAK,GAAGD,MAAM,CAAC,CAAC;gBACxE;gBAEA,IAAID,QAAQ,YAAY;oBACtB,+BAA+B;oBAC/B,MAAMG,eAAeF,MAClBG,OAAO,CAAC,SAAS,MAAM,iBAAiB;qBACxCA,OAAO,CAAC,OAAO,SAAS,mCAAmC;qBAC3DA,OAAO,CAAC,OAAO,QAAQ,gCAAgC;;oBAC1D,MAAMC,QAAQ,IAAIC,OAAO,CAAC,CAAC,EAAEH,aAAa,CAAC,CAAC;oBAC5C,OAAOE,MAAME,IAAI,CAACd,UAAUe,QAAQ;gBACtC;gBAEA,uEAAuE;gBACvE,OAAOf,SAAS,CAACO,IAAiB,KAAKC;YACzC;QACF;IACF,EAAE,OAAM;QACN,OAAO,MAAM,yCAAyC;;IACxD;AACF,EAAC"}

package/dist/utilities/isValidID.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidID: (value: number | string, type: "number" | "ObjectID" | "text") => boolean;
+//# sourceMappingURL=isValidID.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isValidID.d.ts","sourceRoot":"","sources":["../../src/utilities/isValidID.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,SAAS,UACb,MAAM,GAAG,MAAM,QAChB,QAAQ,GAAG,UAAU,GAAG,MAAM,KACnC,OAkBF,CAAA"}

package/dist/utilities/isValidID.js

@@ -0,0 +1,23 @@
+import ObjectIdImport from 'bson-objectid';
+const ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport;
+export const isValidID = (value, type)=>{
+    if (type === 'text' && value) {
+        if ([
+            'object',
+            'string'
+        ].includes(typeof value)) {
+            const isObjectID = ObjectId.isValid(value);
+            return typeof value === 'string' || isObjectID;
+        }
+        return false;
+    }
+    if (type === 'number' && typeof value === 'number' && !Number.isNaN(value)) {
+        return true;
+    }
+    if (type === 'ObjectID') {
+        return ObjectId.isValid(String(value));
+    }
+    return false;
+};
+
+//# sourceMappingURL=isValidID.js.map

package/dist/utilities/isValidID.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isValidID.ts"],"sourcesContent":["import ObjectIdImport from 'bson-objectid'\n\nconst ObjectId = 'default' in ObjectIdImport ? ObjectIdImport.default : ObjectIdImport\n\nexport const isValidID = (\n  value: number | string,\n  type: 'number' | 'ObjectID' | 'text',\n): boolean => {\n  if (type === 'text' && value) {\n    if (['object', 'string'].includes(typeof value)) {\n      const isObjectID = ObjectId.isValid(value as string)\n      return typeof value === 'string' || isObjectID\n    }\n    return false\n  }\n\n  if (type === 'number' && typeof value === 'number' && !Number.isNaN(value)) {\n    return true\n  }\n\n  if (type === 'ObjectID') {\n    return ObjectId.isValid(String(value))\n  }\n\n  return false\n}\n"],"names":["ObjectIdImport","ObjectId","default","isValidID","value","type","includes","isObjectID","isValid","Number","isNaN","String"],"mappings":"AAAA,OAAOA,oBAAoB,gBAAe;AAE1C,MAAMC,WAAW,aAAaD,iBAAiBA,eAAeE,OAAO,GAAGF;AAExE,OAAO,MAAMG,YAAY,CACvBC,OACAC;IAEA,IAAIA,SAAS,UAAUD,OAAO;QAC5B,IAAI;YAAC;YAAU;SAAS,CAACE,QAAQ,CAAC,OAAOF,QAAQ;YAC/C,MAAMG,aAAaN,SAASO,OAAO,CAACJ;YACpC,OAAO,OAAOA,UAAU,YAAYG;QACtC;QACA,OAAO;IACT;IAEA,IAAIF,SAAS,YAAY,OAAOD,UAAU,YAAY,CAACK,OAAOC,KAAK,CAACN,QAAQ;QAC1E,OAAO;IACT;IAEA,IAAIC,SAAS,YAAY;QACvB,OAAOJ,SAASO,OAAO,CAACG,OAAOP;IACjC;IAEA,OAAO;AACT,EAAC"}

package/dist/utilities/isolateObjectProperty.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates a proxy for the given object that has its own property
+ */
+export declare function isolateObjectProperty<T extends object>(object: T, key: (keyof T)[] | keyof T): T;
+//# sourceMappingURL=isolateObjectProperty.d.ts.map

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

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

package/dist/utilities/isolateObjectProperty.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a proxy for the given object that has its own property
+ */ export function isolateObjectProperty(object, key) {
+    const keys = Array.isArray(key) ? key : [
+        key
+    ];
+    const delegate = {};
+    // Initialize delegate with the keys, if they exist in the original object
+    for (const k of keys){
+        if (k in object) {
+            delegate[k] = object[k];
+        }
+    }
+    const handler = {
+        deleteProperty (target, p) {
+            return Reflect.deleteProperty(keys.includes(p) ? delegate : target, p);
+        },
+        get (target, p, receiver) {
+            if (keys.includes(p)) {
+                return Reflect.get(delegate, p, receiver);
+            }
+            // Use target as receiver to preserve private field access (e.g., Request#headers in Node 24+)
+            return Reflect.get(target, p, target);
+        },
+        has (target, p) {
+            return Reflect.has(keys.includes(p) ? delegate : target, p);
+        },
+        set (target, p, newValue, _receiver) {
+            if (keys.includes(p)) {
+                // in case of transactionID we must ignore any receiver, because
+                // "If provided and target does not have a setter for propertyKey, the property will be set on receiver instead."
+                return Reflect.set(delegate, p, newValue);
+            }
+            return Reflect.set(target, p, newValue, target);
+        }
+    };
+    return new Proxy(object, handler);
+}
+
+//# sourceMappingURL=isolateObjectProperty.js.map

package/dist/utilities/isolateObjectProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isolateObjectProperty.ts"],"sourcesContent":["/**\n * Creates a proxy for the given object that has its own property\n */\nexport function isolateObjectProperty<T extends object>(object: T, key: (keyof T)[] | keyof T): T {\n  const keys = Array.isArray(key) ? key : [key]\n  const delegate = {} as T\n\n  // Initialize delegate with the keys, if they exist in the original object\n  for (const k of keys) {\n    if (k in object) {\n      delegate[k] = object[k]\n    }\n  }\n\n  const handler: ProxyHandler<T> = {\n    deleteProperty(target, p): boolean {\n      return Reflect.deleteProperty(keys.includes(p as keyof T) ? delegate : target, p)\n    },\n    get(target, p, receiver) {\n      if (keys.includes(p as keyof T)) {\n        return Reflect.get(delegate, p, receiver)\n      }\n      // Use target as receiver to preserve private field access (e.g., Request#headers in Node 24+)\n      return Reflect.get(target, p, target)\n    },\n    has(target, p) {\n      return Reflect.has(keys.includes(p as keyof T) ? delegate : target, p)\n    },\n    set(target, p, newValue, _receiver) {\n      if (keys.includes(p as keyof T)) {\n        // in case of transactionID we must ignore any receiver, because\n        // \"If provided and target does not have a setter for propertyKey, the property will be set on receiver instead.\"\n        return Reflect.set(delegate, p, newValue)\n      }\n      return Reflect.set(target, p, newValue, target)\n    },\n  }\n  return new Proxy(object, handler)\n}\n"],"names":["isolateObjectProperty","object","key","keys","Array","isArray","delegate","k","handler","deleteProperty","target","p","Reflect","includes","get","receiver","has","set","newValue","_receiver","Proxy"],"mappings":"AAAA;;CAEC,GACD,OAAO,SAASA,sBAAwCC,MAAS,EAAEC,GAA0B;IAC3F,MAAMC,OAAOC,MAAMC,OAAO,CAACH,OAAOA,MAAM;QAACA;KAAI;IAC7C,MAAMI,WAAW,CAAC;IAElB,0EAA0E;IAC1E,KAAK,MAAMC,KAAKJ,KAAM;QACpB,IAAII,KAAKN,QAAQ;YACfK,QAAQ,CAACC,EAAE,GAAGN,MAAM,CAACM,EAAE;QACzB;IACF;IAEA,MAAMC,UAA2B;QAC/BC,gBAAeC,MAAM,EAAEC,CAAC;YACtB,OAAOC,QAAQH,cAAc,CAACN,KAAKU,QAAQ,CAACF,KAAgBL,WAAWI,QAAQC;QACjF;QACAG,KAAIJ,MAAM,EAAEC,CAAC,EAAEI,QAAQ;YACrB,IAAIZ,KAAKU,QAAQ,CAACF,IAAe;gBAC/B,OAAOC,QAAQE,GAAG,CAACR,UAAUK,GAAGI;YAClC;YACA,8FAA8F;YAC9F,OAAOH,QAAQE,GAAG,CAACJ,QAAQC,GAAGD;QAChC;QACAM,KAAIN,MAAM,EAAEC,CAAC;YACX,OAAOC,QAAQI,GAAG,CAACb,KAAKU,QAAQ,CAACF,KAAgBL,WAAWI,QAAQC;QACtE;QACAM,KAAIP,MAAM,EAAEC,CAAC,EAAEO,QAAQ,EAAEC,SAAS;YAChC,IAAIhB,KAAKU,QAAQ,CAACF,IAAe;gBAC/B,gEAAgE;gBAChE,iHAAiH;gBACjH,OAAOC,QAAQK,GAAG,CAACX,UAAUK,GAAGO;YAClC;YACA,OAAON,QAAQK,GAAG,CAACP,QAAQC,GAAGO,UAAUR;QAC1C;IACF;IACA,OAAO,IAAIU,MAAMnB,QAAQO;AAC3B"}

package/dist/utilities/isolateObjectProperty.spec.js

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { isolateObjectProperty } from './isolateObjectProperty.js';
+describe('isolateObjectProperty', ()=>{
+    describe('basic isolation behavior', ()=>{
+        it('should isolate specified property from the original object', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            proxy.a = 100;
+            expect(proxy.a).toBe(100);
+            expect(original.a).toBe(1); // Original unchanged
+        });
+        it('should share non-isolated properties with the original object', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            proxy.b = 200;
+            expect(proxy.b).toBe(200);
+            expect(original.b).toBe(200); // Original also changed
+        });
+        it('should support isolating multiple properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2,
+                c: 3
+            };
+            const proxy = isolateObjectProperty(original, [
+                'a',
+                'b'
+            ]);
+            proxy.a = 100;
+            proxy.b = 200;
+            expect(proxy.a).toBe(100);
+            expect(proxy.b).toBe(200);
+            expect(original.a).toBe(1);
+            expect(original.b).toBe(2);
+        });
+        it('should support deleting isolated properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            delete proxy.a;
+            expect('a' in proxy).toBe(false);
+            expect('a' in original).toBe(true); // Original still has it
+        });
+        it('should support "in" operator for isolated properties', ()=>{
+            const original = {
+                a: 1,
+                b: 2
+            };
+            const proxy = isolateObjectProperty(original, 'a');
+            expect('a' in proxy).toBe(true);
+            expect('b' in proxy).toBe(true);
+            delete proxy.a;
+            expect('a' in proxy).toBe(false);
+        });
+    });
+    describe('private field access (Node 24+ compatibility)', ()=>{
+        /**
+     * Class with private fields to test that the proxy correctly handles
+     * getters/setters that access private fields (Node 24+ compatibility).
+     */ class ObjectWithPrivateFields {
+            #privateValue;
+            constructor(value){
+                this.#privateValue = value;
+            }
+            get value() {
+                return this.#privateValue;
+            }
+            set value(newValue) {
+                this.#privateValue = newValue;
+            }
+        }
+        it('should allow reading properties via getters that access private fields when not isolated', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            expect(original.value).toBe('secret');
+        });
+        it('should allow reading properties via getters that access private fields', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            const proxy = isolateObjectProperty(original, 'nonExistentKey');
+            // This would throw "Cannot read private member" if receiver is wrong
+            expect(proxy.value).toBe('secret');
+        });
+        it('should allow writing properties via setters that access private fields', ()=>{
+            const original = new ObjectWithPrivateFields('secret');
+            const proxy = isolateObjectProperty(original, 'nonExistentKey');
+            // This would throw "Cannot write private member" if receiver is wrong
+            proxy.value = 'updated';
+            expect(proxy.value).toBe('updated');
+            expect(original.value).toBe('updated');
+        });
+        it('should work with Headers-like objects (simulating Request.headers)', ()=>{
+            // Simulate a Request-like object with headers
+            class MockRequest {
+                #headers;
+                constructor(){
+                    this.#headers = new Headers({
+                        'content-type': 'application/json'
+                    });
+                }
+                get headers() {
+                    return this.#headers;
+                }
+            }
+            const request = new MockRequest();
+            const proxy = isolateObjectProperty(request, 'nonExistentKey');
+            // This simulates what happens in createLocalReq when checking req.headers
+            expect(proxy.headers).toBeInstanceOf(Headers);
+            expect(proxy.headers.get('content-type')).toBe('application/json');
+        });
+    });
+});
+
+//# sourceMappingURL=isolateObjectProperty.spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isolateObjectProperty.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { isolateObjectProperty } from './isolateObjectProperty.js'\n\ndescribe('isolateObjectProperty', () => {\n  describe('basic isolation behavior', () => {\n    it('should isolate specified property from the original object', () => {\n      const original = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      proxy.a = 100\n\n      expect(proxy.a).toBe(100)\n      expect(original.a).toBe(1) // Original unchanged\n    })\n\n    it('should share non-isolated properties with the original object', () => {\n      const original = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      proxy.b = 200\n\n      expect(proxy.b).toBe(200)\n      expect(original.b).toBe(200) // Original also changed\n    })\n\n    it('should support isolating multiple properties', () => {\n      const original = { a: 1, b: 2, c: 3 }\n      const proxy = isolateObjectProperty(original, ['a', 'b'])\n\n      proxy.a = 100\n      proxy.b = 200\n\n      expect(proxy.a).toBe(100)\n      expect(proxy.b).toBe(200)\n      expect(original.a).toBe(1)\n      expect(original.b).toBe(2)\n    })\n\n    it('should support deleting isolated properties', () => {\n      const original: Record<string, any> = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      delete proxy.a\n\n      expect('a' in proxy).toBe(false)\n      expect('a' in original).toBe(true) // Original still has it\n    })\n\n    it('should support \"in\" operator for isolated properties', () => {\n      const original: Record<string, any> = { a: 1, b: 2 }\n      const proxy = isolateObjectProperty(original, 'a')\n\n      expect('a' in proxy).toBe(true)\n      expect('b' in proxy).toBe(true)\n\n      delete proxy.a\n      expect('a' in proxy).toBe(false)\n    })\n  })\n\n  describe('private field access (Node 24+ compatibility)', () => {\n    /**\n     * Class with private fields to test that the proxy correctly handles\n     * getters/setters that access private fields (Node 24+ compatibility).\n     */\n    class ObjectWithPrivateFields {\n      #privateValue: string\n\n      constructor(value: string) {\n        this.#privateValue = value\n      }\n\n      get value(): string {\n        return this.#privateValue\n      }\n\n      set value(newValue: string) {\n        this.#privateValue = newValue\n      }\n    }\n\n    it('should allow reading properties via getters that access private fields when not isolated', () => {\n      const original = new ObjectWithPrivateFields('secret')\n\n      expect(original.value).toBe('secret')\n    })\n\n    it('should allow reading properties via getters that access private fields', () => {\n      const original = new ObjectWithPrivateFields('secret')\n      const proxy = isolateObjectProperty(original, 'nonExistentKey' as keyof typeof original)\n\n      // This would throw \"Cannot read private member\" if receiver is wrong\n      expect(proxy.value).toBe('secret')\n    })\n\n    it('should allow writing properties via setters that access private fields', () => {\n      const original = new ObjectWithPrivateFields('secret')\n      const proxy = isolateObjectProperty(original, 'nonExistentKey' as keyof typeof original)\n\n      // This would throw \"Cannot write private member\" if receiver is wrong\n      proxy.value = 'updated'\n\n      expect(proxy.value).toBe('updated')\n      expect(original.value).toBe('updated')\n    })\n\n    it('should work with Headers-like objects (simulating Request.headers)', () => {\n      // Simulate a Request-like object with headers\n      class MockRequest {\n        #headers: Headers\n\n        constructor() {\n          this.#headers = new Headers({ 'content-type': 'application/json' })\n        }\n\n        get headers(): Headers {\n          return this.#headers\n        }\n      }\n\n      const request = new MockRequest()\n      const proxy = isolateObjectProperty(request, 'nonExistentKey' as keyof typeof request)\n\n      // This simulates what happens in createLocalReq when checking req.headers\n      expect(proxy.headers).toBeInstanceOf(Headers)\n      expect(proxy.headers.get('content-type')).toBe('application/json')\n    })\n  })\n})\n"],"names":["describe","expect","it","isolateObjectProperty","original","a","b","proxy","toBe","c","ObjectWithPrivateFields","value","newValue","MockRequest","Headers","headers","request","toBeInstanceOf","get"],"mappings":"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"}

package/dist/utilities/killTransaction.d.ts

@@ -0,0 +1,7 @@
+import type { MarkRequired } from 'ts-essentials';
+import type { PayloadRequest } from '../types/index.js';
+/**
+ * Rollback the transaction from the req using the db adapter and removes it from the req
+ */
+export declare function killTransaction(req: MarkRequired<Partial<PayloadRequest>, 'payload'>): Promise<void>;
+//# sourceMappingURL=killTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"killTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/killTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/utilities/killTransaction.js

@@ -0,0 +1,15 @@
+/**
+ * Rollback the transaction from the req using the db adapter and removes it from the req
+ */ export async function killTransaction(req) {
+    const { payload, transactionID } = req;
+    if (transactionID && !(transactionID instanceof Promise)) {
+        try {
+            await payload.db.rollbackTransaction(req.transactionID);
+        } catch (ignore) {
+        // swallow any errors while attempting to rollback
+        }
+        delete req.transactionID;
+    }
+}
+
+//# sourceMappingURL=killTransaction.js.map

package/dist/utilities/killTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/killTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\n/**\n * Rollback the transaction from the req using the db adapter and removes it from the req\n */\nexport async function killTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<void> {\n  const { payload, transactionID } = req\n  if (transactionID && !(transactionID instanceof Promise)) {\n    try {\n      await payload.db.rollbackTransaction(req.transactionID!)\n    } catch (ignore) {\n      // swallow any errors while attempting to rollback\n    }\n    delete req.transactionID\n  }\n}\n"],"names":["killTransaction","req","payload","transactionID","Promise","db","rollbackTransaction","ignore"],"mappings":"AAIA;;CAEC,GACD,OAAO,eAAeA,gBACpBC,GAAqD;IAErD,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGF;IACnC,IAAIE,iBAAiB,CAAEA,CAAAA,yBAAyBC,OAAM,GAAI;QACxD,IAAI;YACF,MAAMF,QAAQG,EAAE,CAACC,mBAAmB,CAACL,IAAIE,aAAa;QACxD,EAAE,OAAOI,QAAQ;QACf,kDAAkD;QACpD;QACA,OAAON,IAAIE,aAAa;IAC1B;AACF"}