@depup/payload 3.79.1-depup.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"getBlockSelect.d.ts","sourceRoot":"","sources":["../../src/utilities/getBlockSelect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,cAAc,mCAIxB;IACD,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAA;CACvB,KAAG;IAAE,WAAW,EAAE,OAAO,GAAG,UAAU,CAAC;IAAC,eAAe,EAAE,UAAU,CAAA;CAqCnE,CAAA"}

package/dist/utilities/getBlockSelect.js

@@ -0,0 +1,42 @@
+/**
+ * This is used for the Select API to determine the select level of a block.
+ * It will ensure that `id` and `blockType` are always included in the select object.
+ * @returns { blockSelect: boolean | SelectType, blockSelectMode: SelectMode }
+ */ export const getBlockSelect = ({ block, select, selectMode })=>{
+    if (typeof select === 'object') {
+        let blockSelectMode = selectMode;
+        const blocksSelect = {
+            ...select
+        };
+        let blockSelect = blocksSelect[block.slug];
+        // sanitize `{ blocks: { cta: false }}` to `{ blocks: { cta: { id: true, blockType: true }}}`
+        if (selectMode === 'exclude' && blockSelect === false) {
+            blockSelectMode = 'include';
+            blockSelect = {
+                id: true,
+                blockType: true
+            };
+        } else if (selectMode === 'include') {
+            if (!blockSelect) {
+                blockSelect = {};
+            }
+            if (typeof blockSelect === 'object') {
+                blockSelect = {
+                    ...blockSelect
+                };
+                blockSelect['id'] = true;
+                blockSelect['blockType'] = true;
+            }
+        }
+        return {
+            blockSelect: blockSelect,
+            blockSelectMode
+        };
+    }
+    return {
+        blockSelect: select,
+        blockSelectMode: selectMode
+    };
+};
+
+//# sourceMappingURL=getBlockSelect.js.map

package/dist/utilities/getBlockSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getBlockSelect.ts"],"sourcesContent":["import type { Block } from '../fields/config/types.js'\nimport type { SelectMode, SelectType } from '../types/index.js'\n\n/**\n * This is used for the Select API to determine the select level of a block.\n * It will ensure that `id` and `blockType` are always included in the select object.\n * @returns { blockSelect: boolean | SelectType, blockSelectMode: SelectMode }\n */\nexport const getBlockSelect = ({\n  block,\n  select,\n  selectMode,\n}: {\n  block: Block\n  select: SelectType[string]\n  selectMode: SelectMode\n}): { blockSelect: boolean | SelectType; blockSelectMode: SelectMode } => {\n  if (typeof select === 'object') {\n    let blockSelectMode = selectMode\n\n    const blocksSelect = {\n      ...select,\n    }\n\n    let blockSelect = blocksSelect[block.slug]\n\n    // sanitize `{ blocks: { cta: false }}` to `{ blocks: { cta: { id: true, blockType: true }}}`\n    if (selectMode === 'exclude' && blockSelect === false) {\n      blockSelectMode = 'include'\n\n      blockSelect = {\n        id: true,\n        blockType: true,\n      }\n    } else if (selectMode === 'include') {\n      if (!blockSelect) {\n        blockSelect = {}\n      }\n\n      if (typeof blockSelect === 'object') {\n        blockSelect = {\n          ...blockSelect,\n        }\n\n        blockSelect['id'] = true\n        blockSelect['blockType'] = true\n      }\n    }\n\n    return { blockSelect: blockSelect!, blockSelectMode }\n  }\n\n  return { blockSelect: select, blockSelectMode: selectMode }\n}\n"],"names":["getBlockSelect","block","select","selectMode","blockSelectMode","blocksSelect","blockSelect","slug","id","blockType"],"mappings":"AAGA;;;;CAIC,GACD,OAAO,MAAMA,iBAAiB,CAAC,EAC7BC,KAAK,EACLC,MAAM,EACNC,UAAU,EAKX;IACC,IAAI,OAAOD,WAAW,UAAU;QAC9B,IAAIE,kBAAkBD;QAEtB,MAAME,eAAe;YACnB,GAAGH,MAAM;QACX;QAEA,IAAII,cAAcD,YAAY,CAACJ,MAAMM,IAAI,CAAC;QAE1C,6FAA6F;QAC7F,IAAIJ,eAAe,aAAaG,gBAAgB,OAAO;YACrDF,kBAAkB;YAElBE,cAAc;gBACZE,IAAI;gBACJC,WAAW;YACb;QACF,OAAO,IAAIN,eAAe,WAAW;YACnC,IAAI,CAACG,aAAa;gBAChBA,cAAc,CAAC;YACjB;YAEA,IAAI,OAAOA,gBAAgB,UAAU;gBACnCA,cAAc;oBACZ,GAAGA,WAAW;gBAChB;gBAEAA,WAAW,CAAC,KAAK,GAAG;gBACpBA,WAAW,CAAC,YAAY,GAAG;YAC7B;QACF;QAEA,OAAO;YAAEA,aAAaA;YAAcF;QAAgB;IACtD;IAEA,OAAO;QAAEE,aAAaJ;QAAQE,iBAAiBD;IAAW;AAC5D,EAAC"}

package/dist/utilities/getCollectionIDFieldTypes.d.ts

@@ -0,0 +1,13 @@
+import type { SanitizedConfig } from '../config/types.js';
+/**
+ *  While the default ID is determined by the db adapter, it can still differ for a collection if they
+ *  define a custom ID field. This builds a map of collection slugs to their ID field type.
+ * @param defaultIDType as defined by the database adapter
+ */
+export declare function getCollectionIDFieldTypes({ config, defaultIDType, }: {
+    config: SanitizedConfig;
+    defaultIDType: 'number' | 'text';
+}): {
+    [key: string]: 'number' | 'string';
+};
+//# sourceMappingURL=getCollectionIDFieldTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCollectionIDFieldTypes.d.ts","sourceRoot":"","sources":["../../src/utilities/getCollectionIDFieldTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEzD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,MAAM,EACN,aAAa,GACd,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,aAAa,EAAE,QAAQ,GAAG,MAAM,CAAA;CACjC,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAA;CAAE,CAiBzC"}

package/dist/utilities/getCollectionIDFieldTypes.js

@@ -0,0 +1,16 @@
+/**
+ *  While the default ID is determined by the db adapter, it can still differ for a collection if they
+ *  define a custom ID field. This builds a map of collection slugs to their ID field type.
+ * @param defaultIDType as defined by the database adapter
+ */ export function getCollectionIDFieldTypes({ config, defaultIDType }) {
+    return config.collections.reduce((acc, collection)=>{
+        const customCollectionIdField = collection.fields.find((field)=>'name' in field && field.name === 'id');
+        acc[collection.slug] = defaultIDType === 'text' ? 'string' : 'number';
+        if (customCollectionIdField) {
+            acc[collection.slug] = customCollectionIdField.type === 'number' ? 'number' : 'string';
+        }
+        return acc;
+    }, {});
+}
+
+//# sourceMappingURL=getCollectionIDFieldTypes.js.map

package/dist/utilities/getCollectionIDFieldTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getCollectionIDFieldTypes.ts"],"sourcesContent":["import type { SanitizedConfig } from '../config/types.js'\n\n/**\n *  While the default ID is determined by the db adapter, it can still differ for a collection if they\n *  define a custom ID field. This builds a map of collection slugs to their ID field type.\n * @param defaultIDType as defined by the database adapter\n */\nexport function getCollectionIDFieldTypes({\n  config,\n  defaultIDType,\n}: {\n  config: SanitizedConfig\n  defaultIDType: 'number' | 'text'\n}): { [key: string]: 'number' | 'string' } {\n  return config.collections.reduce(\n    (acc, collection) => {\n      const customCollectionIdField = collection.fields.find(\n        (field) => 'name' in field && field.name === 'id',\n      )\n\n      acc[collection.slug] = defaultIDType === 'text' ? 'string' : 'number'\n\n      if (customCollectionIdField) {\n        acc[collection.slug] = customCollectionIdField.type === 'number' ? 'number' : 'string'\n      }\n\n      return acc\n    },\n    {} as Record<string, 'number' | 'string'>,\n  )\n}\n"],"names":["getCollectionIDFieldTypes","config","defaultIDType","collections","reduce","acc","collection","customCollectionIdField","fields","find","field","name","slug","type"],"mappings":"AAEA;;;;CAIC,GACD,OAAO,SAASA,0BAA0B,EACxCC,MAAM,EACNC,aAAa,EAId;IACC,OAAOD,OAAOE,WAAW,CAACC,MAAM,CAC9B,CAACC,KAAKC;QACJ,MAAMC,0BAA0BD,WAAWE,MAAM,CAACC,IAAI,CACpD,CAACC,QAAU,UAAUA,SAASA,MAAMC,IAAI,KAAK;QAG/CN,GAAG,CAACC,WAAWM,IAAI,CAAC,GAAGV,kBAAkB,SAAS,WAAW;QAE7D,IAAIK,yBAAyB;YAC3BF,GAAG,CAACC,WAAWM,IAAI,CAAC,GAAGL,wBAAwBM,IAAI,KAAK,WAAW,WAAW;QAChF;QAEA,OAAOR;IACT,GACA,CAAC;AAEL"}

package/dist/utilities/getDataByPath.d.ts

@@ -0,0 +1,3 @@
+import type { FormState } from '../admin/types.js';
+export declare const getDataByPath: <T = unknown>(fields: FormState, path: string) => T;
+//# sourceMappingURL=getDataByPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDataByPath.d.ts","sourceRoot":"","sources":["../../src/utilities/getDataByPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAIlD,eAAO,MAAM,aAAa,GAAI,CAAC,oBAAoB,SAAS,QAAQ,MAAM,KAAG,CAkB5E,CAAA"}

package/dist/utilities/getDataByPath.js

@@ -0,0 +1,18 @@
+import { unflatten } from './unflatten.js';
+export const getDataByPath = (fields, path)=>{
+    const pathPrefixToRemove = path.substring(0, path.lastIndexOf('.') + 1);
+    const name = path.split('.').pop();
+    const data = {};
+    Object.keys(fields).forEach((key)=>{
+        if (!fields[key]?.disableFormData && (key.indexOf(`${path}.`) === 0 || key === path)) {
+            data[key.replace(pathPrefixToRemove, '')] = fields[key]?.value;
+            if (fields[key]?.rows && fields[key].rows.length === 0) {
+                data[key.replace(pathPrefixToRemove, '')] = [];
+            }
+        }
+    });
+    const unflattenedData = unflatten(data);
+    return unflattenedData?.[name];
+};
+
+//# sourceMappingURL=getDataByPath.js.map

package/dist/utilities/getDataByPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/getDataByPath.ts"],"sourcesContent":["import type { FormState } from '../admin/types.js'\n\nimport { unflatten } from './unflatten.js'\n\nexport const getDataByPath = <T = unknown>(fields: FormState, path: string): T => {\n  const pathPrefixToRemove = path.substring(0, path.lastIndexOf('.') + 1)\n  const name = path.split('.').pop()\n\n  const data: Record<string, any> = {}\n  Object.keys(fields).forEach((key) => {\n    if (!fields[key]?.disableFormData && (key.indexOf(`${path}.`) === 0 || key === path)) {\n      data[key.replace(pathPrefixToRemove, '')] = fields[key]?.value\n\n      if (fields[key]?.rows && fields[key].rows.length === 0) {\n        data[key.replace(pathPrefixToRemove, '')] = []\n      }\n    }\n  })\n\n  const unflattenedData = unflatten(data)\n\n  return unflattenedData?.[name!]\n}\n"],"names":["unflatten","getDataByPath","fields","path","pathPrefixToRemove","substring","lastIndexOf","name","split","pop","data","Object","keys","forEach","key","disableFormData","indexOf","replace","value","rows","length","unflattenedData"],"mappings":"AAEA,SAASA,SAAS,QAAQ,iBAAgB;AAE1C,OAAO,MAAMC,gBAAgB,CAAcC,QAAmBC;IAC5D,MAAMC,qBAAqBD,KAAKE,SAAS,CAAC,GAAGF,KAAKG,WAAW,CAAC,OAAO;IACrE,MAAMC,OAAOJ,KAAKK,KAAK,CAAC,KAAKC,GAAG;IAEhC,MAAMC,OAA4B,CAAC;IACnCC,OAAOC,IAAI,CAACV,QAAQW,OAAO,CAAC,CAACC;QAC3B,IAAI,CAACZ,MAAM,CAACY,IAAI,EAAEC,mBAAoBD,CAAAA,IAAIE,OAAO,CAAC,GAAGb,KAAK,CAAC,CAAC,MAAM,KAAKW,QAAQX,IAAG,GAAI;YACpFO,IAAI,CAACI,IAAIG,OAAO,CAACb,oBAAoB,IAAI,GAAGF,MAAM,CAACY,IAAI,EAAEI;YAEzD,IAAIhB,MAAM,CAACY,IAAI,EAAEK,QAAQjB,MAAM,CAACY,IAAI,CAACK,IAAI,CAACC,MAAM,KAAK,GAAG;gBACtDV,IAAI,CAACI,IAAIG,OAAO,CAACb,oBAAoB,IAAI,GAAG,EAAE;YAChD;QACF;IACF;IAEA,MAAMiB,kBAAkBrB,UAAUU;IAElC,OAAOW,iBAAiB,CAACd,KAAM;AACjC,EAAC"}

package/dist/utilities/getEntityPermissions/entityDocExists.d.ts

@@ -0,0 +1,14 @@
+import { type AllOperations, type DefaultDocumentIDType, type PayloadRequest, type Where } from '../../index.js';
+/**
+ * Returns whether or not the entity doc exists based on the where query.
+ */
+export declare function entityDocExists({ id, slug, entityType, locale, operation, req, where, }: {
+    entityType: 'collection' | 'global';
+    id?: DefaultDocumentIDType;
+    locale?: string;
+    operation?: AllOperations;
+    req: PayloadRequest;
+    slug: string;
+    where: Where;
+}): Promise<boolean>;
+//# sourceMappingURL=entityDocExists.d.ts.map

package/dist/utilities/getEntityPermissions/entityDocExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityDocExists.d.ts","sourceRoot":"","sources":["../../../src/utilities/getEntityPermissions/entityDocExists.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,KAAK,EACX,MAAM,gBAAgB,CAAA;AAEvB;;GAEG;AACH,wBAAsB,eAAe,CAAC,EACpC,EAAE,EACF,IAAI,EACJ,UAAU,EACV,MAAM,EACN,SAAS,EACT,GAAG,EACH,KAAK,GACN,EAAE;IACD,UAAU,EAAE,YAAY,GAAG,QAAQ,CAAA;IACnC,EAAE,CAAC,EAAE,qBAAqB,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,aAAa,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,KAAK,CAAA;CACb,GAAG,OAAO,CAAC,OAAO,CAAC,CAqCnB"}

package/dist/utilities/getEntityPermissions/entityDocExists.js

@@ -0,0 +1,45 @@
+import { combineQueries } from '../../index.js';
+/**
+ * Returns whether or not the entity doc exists based on the where query.
+ */ export async function entityDocExists({ id, slug, entityType, locale, operation, req, where }) {
+    if (entityType === 'global') {
+        const global = await req.payload.db.findGlobal({
+            slug,
+            locale,
+            req,
+            select: {},
+            where
+        });
+        const hasGlobalDoc = Boolean(global && Object.keys(global).length > 0);
+        return hasGlobalDoc;
+    }
+    if (entityType === 'collection' && id) {
+        if (operation === 'readVersions') {
+            const count = await req.payload.db.countVersions({
+                collection: slug,
+                locale,
+                req,
+                where: combineQueries(where, {
+                    parent: {
+                        equals: id
+                    }
+                })
+            });
+            return count.totalDocs > 0;
+        }
+        const count = await req.payload.db.count({
+            collection: slug,
+            locale,
+            req,
+            where: combineQueries(where, {
+                id: {
+                    equals: id
+                }
+            })
+        });
+        return count.totalDocs > 0;
+    }
+    return false;
+}
+
+//# sourceMappingURL=entityDocExists.js.map

package/dist/utilities/getEntityPermissions/entityDocExists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/getEntityPermissions/entityDocExists.ts"],"sourcesContent":["import {\n  type AllOperations,\n  combineQueries,\n  type DefaultDocumentIDType,\n  type PayloadRequest,\n  type Where,\n} from '../../index.js'\n\n/**\n * Returns whether or not the entity doc exists based on the where query.\n */\nexport async function entityDocExists({\n  id,\n  slug,\n  entityType,\n  locale,\n  operation,\n  req,\n  where,\n}: {\n  entityType: 'collection' | 'global'\n  id?: DefaultDocumentIDType\n  locale?: string\n  operation?: AllOperations\n  req: PayloadRequest\n  slug: string\n  where: Where\n}): Promise<boolean> {\n  if (entityType === 'global') {\n    const global = await req.payload.db.findGlobal({\n      slug,\n      locale,\n      req,\n      select: {},\n      where,\n    })\n\n    const hasGlobalDoc = Boolean(global && Object.keys(global).length > 0)\n\n    return hasGlobalDoc\n  }\n\n  if (entityType === 'collection' && id) {\n    if (operation === 'readVersions') {\n      const count = await req.payload.db.countVersions({\n        collection: slug,\n        locale,\n        req,\n        where: combineQueries(where, { parent: { equals: id } }),\n      })\n      return count.totalDocs > 0\n    }\n\n    const count = await req.payload.db.count({\n      collection: slug,\n      locale,\n      req,\n      where: combineQueries(where, { id: { equals: id } }),\n    })\n\n    return count.totalDocs > 0\n  }\n\n  return false\n}\n"],"names":["combineQueries","entityDocExists","id","slug","entityType","locale","operation","req","where","global","payload","db","findGlobal","select","hasGlobalDoc","Boolean","Object","keys","length","count","countVersions","collection","parent","equals","totalDocs"],"mappings":"AAAA,SAEEA,cAAc,QAIT,iBAAgB;AAEvB;;CAEC,GACD,OAAO,eAAeC,gBAAgB,EACpCC,EAAE,EACFC,IAAI,EACJC,UAAU,EACVC,MAAM,EACNC,SAAS,EACTC,GAAG,EACHC,KAAK,EASN;IACC,IAAIJ,eAAe,UAAU;QAC3B,MAAMK,SAAS,MAAMF,IAAIG,OAAO,CAACC,EAAE,CAACC,UAAU,CAAC;YAC7CT;YACAE;YACAE;YACAM,QAAQ,CAAC;YACTL;QACF;QAEA,MAAMM,eAAeC,QAAQN,UAAUO,OAAOC,IAAI,CAACR,QAAQS,MAAM,GAAG;QAEpE,OAAOJ;IACT;IAEA,IAAIV,eAAe,gBAAgBF,IAAI;QACrC,IAAII,cAAc,gBAAgB;YAChC,MAAMa,QAAQ,MAAMZ,IAAIG,OAAO,CAACC,EAAE,CAACS,aAAa,CAAC;gBAC/CC,YAAYlB;gBACZE;gBACAE;gBACAC,OAAOR,eAAeQ,OAAO;oBAAEc,QAAQ;wBAAEC,QAAQrB;oBAAG;gBAAE;YACxD;YACA,OAAOiB,MAAMK,SAAS,GAAG;QAC3B;QAEA,MAAML,QAAQ,MAAMZ,IAAIG,OAAO,CAACC,EAAE,CAACQ,KAAK,CAAC;YACvCE,YAAYlB;YACZE;YACAE;YACAC,OAAOR,eAAeQ,OAAO;gBAAEN,IAAI;oBAAEqB,QAAQrB;gBAAG;YAAE;QACpD;QAEA,OAAOiB,MAAMK,SAAS,GAAG;IAC3B;IAEA,OAAO;AACT"}

package/dist/utilities/getEntityPermissions/getEntityPermissions.d.ts

@@ -0,0 +1,52 @@
+import type { BlockPermissions, CollectionPermission, GlobalPermission } from '../../auth/types.js';
+import type { SanitizedCollectionConfig, TypeWithID } from '../../collections/config/types.js';
+import type { SanitizedGlobalConfig } from '../../globals/config/types.js';
+import type { BlockSlug, DefaultDocumentIDType } from '../../index.js';
+import type { AllOperations, JsonObject, PayloadRequest } from '../../types/index.js';
+export type BlockReferencesPermissions = Record<BlockSlug, BlockPermissions | Promise<BlockPermissions>>;
+export type EntityDoc = JsonObject | TypeWithID;
+type ReturnType<TEntityType extends 'collection' | 'global'> = TEntityType extends 'global' ? GlobalPermission : CollectionPermission;
+type Args<TEntityType extends 'collection' | 'global'> = {
+    blockReferencesPermissions: BlockReferencesPermissions;
+    /**
+     * If the document data is passed, it will be used to check access instead of fetching the document from the database.
+     */
+    data?: JsonObject;
+    entity: TEntityType extends 'collection' ? SanitizedCollectionConfig : SanitizedGlobalConfig;
+    entityType: TEntityType;
+    /**
+     * Operations to check access for
+     */
+    operations: AllOperations[];
+    req: PayloadRequest;
+} & ({
+    fetchData: false;
+    id?: never;
+} | {
+    fetchData: true;
+    id: TEntityType extends 'collection' ? DefaultDocumentIDType : undefined;
+});
+/**
+ * Build up permissions object for an entity (collection or global).
+ * This is not run during any update and reflects the current state of the entity data => doc and data is the same.
+ *
+ * When `fetchData` is false:
+ * - returned `Where` are not run and evaluated as "does not have permission".
+ * - If req.data is passed: `data` and `doc` is passed to access functions.
+ * - If req.data is not passed: `data` and `doc` is not passed to access functions.
+ *
+ * When `fetchData` is true:
+ * - `Where` are run and evaluated as "has permission" or "does not have permission".
+ * - `data` and `doc` are always passed to access functions.
+ * - Error is thrown if `entityType` is 'collection' and `id` is not passed.
+ *
+ * In both cases:
+ * We cannot include siblingData or blockData here, as we do not have siblingData available once we reach block or array
+ * rows, as we're calculating schema permissions, which do not include individual rows.
+ * For consistency, it's thus better to never include the siblingData and blockData
+ *
+ * @internal
+ */
+export declare function getEntityPermissions<TEntityType extends 'collection' | 'global'>(args: Args<TEntityType>): Promise<ReturnType<TEntityType>>;
+export {};
+//# sourceMappingURL=getEntityPermissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getEntityPermissions.d.ts","sourceRoot":"","sources":["../../../src/utilities/getEntityPermissions/getEntityPermissions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EAEpB,gBAAgB,EAEjB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,yBAAyB,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAC9F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,cAAc,EAAS,MAAM,sBAAsB,CAAA;AAO5F,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAC7C,SAAS,EACT,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAC7C,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,UAAU,CAAA;AAE/C,KAAK,UAAU,CAAC,WAAW,SAAS,YAAY,GAAG,QAAQ,IAAI,WAAW,SAAS,QAAQ,GACvF,gBAAgB,GAChB,oBAAoB,CAAA;AAExB,KAAK,IAAI,CAAC,WAAW,SAAS,YAAY,GAAG,QAAQ,IAAI;IACvD,0BAA0B,EAAE,0BAA0B,CAAA;IACtD;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,WAAW,SAAS,YAAY,GAAG,yBAAyB,GAAG,qBAAqB,CAAA;IAC5F,UAAU,EAAE,WAAW,CAAA;IACvB;;OAEG;IACH,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,CACA;IACE,SAAS,EAAE,KAAK,CAAA;IAChB,EAAE,CAAC,EAAE,KAAK,CAAA;CACX,GACD;IACE,SAAS,EAAE,IAAI,CAAA;IACf,EAAE,EAAE,WAAW,SAAS,YAAY,GAAG,qBAAqB,GAAG,SAAS,CAAA;CACzE,CACJ,CAAA;AAYD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,oBAAoB,CAAC,WAAW,SAAS,YAAY,GAAG,QAAQ,EACpF,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,GACtB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAwJlC"}

package/dist/utilities/getEntityPermissions/getEntityPermissions.js

@@ -0,0 +1,193 @@
+import { isDeepStrictEqual } from 'util';
+import { entityDocExists } from './entityDocExists.js';
+import { populateFieldPermissions } from './populateFieldPermissions.js';
+const topLevelCollectionPermissions = [
+    'create',
+    'delete',
+    'read',
+    'readVersions',
+    'update',
+    'unlock'
+];
+const topLevelGlobalPermissions = [
+    'read',
+    'readVersions',
+    'update'
+];
+/**
+ * Build up permissions object for an entity (collection or global).
+ * This is not run during any update and reflects the current state of the entity data => doc and data is the same.
+ *
+ * When `fetchData` is false:
+ * - returned `Where` are not run and evaluated as "does not have permission".
+ * - If req.data is passed: `data` and `doc` is passed to access functions.
+ * - If req.data is not passed: `data` and `doc` is not passed to access functions.
+ *
+ * When `fetchData` is true:
+ * - `Where` are run and evaluated as "has permission" or "does not have permission".
+ * - `data` and `doc` are always passed to access functions.
+ * - Error is thrown if `entityType` is 'collection' and `id` is not passed.
+ *
+ * In both cases:
+ * We cannot include siblingData or blockData here, as we do not have siblingData available once we reach block or array
+ * rows, as we're calculating schema permissions, which do not include individual rows.
+ * For consistency, it's thus better to never include the siblingData and blockData
+ *
+ * @internal
+ */ export async function getEntityPermissions(args) {
+    const { id, blockReferencesPermissions, data: _data, entity, entityType, fetchData, operations, req } = args;
+    const { locale: _locale, user } = req;
+    const locale = _locale ? _locale : undefined;
+    if (fetchData && entityType === 'collection' && !id) {
+        throw new Error('ID is required when fetching data for a collection');
+    }
+    const hasData = _data && Object.keys(_data).length > 0;
+    const data = hasData ? _data : fetchData ? await (async ()=>{
+        if (entityType === 'global') {
+            return req.payload.findGlobal({
+                slug: entity.slug,
+                depth: 0,
+                fallbackLocale: null,
+                locale,
+                overrideAccess: true,
+                req
+            });
+        }
+        if (entityType === 'collection') {
+            return req.payload.findByID({
+                id: id,
+                collection: entity.slug,
+                depth: 0,
+                fallbackLocale: null,
+                locale,
+                overrideAccess: true,
+                req,
+                trash: true
+            });
+        }
+    })() : undefined;
+    const isLoggedIn = !!user;
+    const fieldsPermissions = {};
+    const entityPermissions = {
+        fields: fieldsPermissions
+    };
+    const promises = [];
+    // Phase 1: Resolve all access functions to get where queries
+    const accessResults = [];
+    for (const _operation of operations){
+        const operation = _operation;
+        const accessFunction = entity.access[operation];
+        if (entityType === 'collection' && topLevelCollectionPermissions.includes(operation) || entityType === 'global' && topLevelGlobalPermissions.includes(operation)) {
+            if (typeof accessFunction === 'function') {
+                accessResults.push({
+                    operation,
+                    result: Promise.resolve(accessFunction({
+                        id,
+                        data,
+                        req
+                    }))
+                });
+            } else {
+                entityPermissions[operation] = {
+                    permission: isLoggedIn
+                };
+            }
+        }
+    }
+    // Await all access functions in parallel
+    const resolvedAccessResults = await Promise.all(accessResults.map(async (item)=>({
+            operation: item.operation,
+            result: await item.result
+        })));
+    // Phase 2: Process where queries with cache and resolve in parallel
+    const whereQueryCache = [];
+    const wherePromises = [];
+    for (const { operation, result: accessResult } of resolvedAccessResults){
+        if (typeof accessResult === 'object') {
+            processWhereQuery({
+                id,
+                slug: entity.slug,
+                accessResult,
+                entityPermissions,
+                entityType,
+                fetchData,
+                locale,
+                operation,
+                req,
+                wherePromises,
+                whereQueryCache
+            });
+        } else if (entityPermissions[operation]?.permission !== false) {
+            entityPermissions[operation] = {
+                permission: !!accessResult
+            };
+        }
+    }
+    // Await all where query DB calls in parallel
+    await Promise.all(wherePromises);
+    populateFieldPermissions({
+        blockReferencesPermissions,
+        data,
+        fields: entity.fields,
+        operations,
+        parentPermissionsObject: entityPermissions,
+        permissionsObject: fieldsPermissions,
+        promises,
+        req
+    });
+    /**
+   * Await all promises in parallel.
+   * A promise can add more promises to the promises array (group of fields calls populateFieldPermissions again in their own promise), which will not be
+   * awaited in the first run.
+   * This is why we need to loop again to process the new promises, until there are no more promises left.
+   */ let iterations = 0;
+    while(promises.length > 0){
+        const currentPromises = promises.splice(0, promises.length);
+        await Promise.all(currentPromises);
+        iterations++;
+        if (iterations >= 100) {
+            throw new Error('Infinite getEntityPermissions promise loop detected.');
+        }
+    }
+    return entityPermissions;
+}
+const processWhereQuery = ({ id, slug, accessResult, entityPermissions, entityType, fetchData, locale, operation, req, wherePromises, whereQueryCache })=>{
+    if (fetchData) {
+        // Check cache for identical where query using deep comparison
+        let cached = whereQueryCache.find((entry)=>isDeepStrictEqual(entry.where, accessResult));
+        if (!cached) {
+            // Cache miss - start DB query (don't await)
+            cached = {
+                result: entityDocExists({
+                    id,
+                    slug,
+                    entityType,
+                    locale,
+                    operation,
+                    req,
+                    where: accessResult
+                }),
+                where: accessResult
+            };
+            whereQueryCache.push(cached);
+        }
+        // Defer resolution to Promise.all (cache hits reuse same promise)
+        wherePromises.push(cached.result.then((hasPermission)=>{
+            entityPermissions[operation] = {
+                permission: hasPermission,
+                where: accessResult
+            };
+        }));
+    } else {
+        // TODO: 4.0: Investigate defaulting to `false` here, if where query is returned but ignored as we don't
+        // have the document data available. This seems more secure.
+        // Alternatively, we could set permission to a third state, like 'unknown'.
+        // Even after calling sanitizePermissions, the permissions will still be true if the where query is returned but ignored as we don't have the document data available.
+        entityPermissions[operation] = {
+            permission: true,
+            where: accessResult
+        };
+    }
+};
+
+//# sourceMappingURL=getEntityPermissions.js.map

package/dist/utilities/getEntityPermissions/getEntityPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/getEntityPermissions/getEntityPermissions.ts"],"sourcesContent":["import { isDeepStrictEqual } from 'util'\n\nimport type {\n  BlockPermissions,\n  CollectionPermission,\n  FieldsPermissions,\n  GlobalPermission,\n  Permission,\n} from '../../auth/types.js'\nimport type { SanitizedCollectionConfig, TypeWithID } from '../../collections/config/types.js'\nimport type { SanitizedGlobalConfig } from '../../globals/config/types.js'\nimport type { BlockSlug, DefaultDocumentIDType } from '../../index.js'\nimport type { AllOperations, JsonObject, PayloadRequest, Where } from '../../types/index.js'\n\nimport { entityDocExists } from './entityDocExists.js'\nimport { populateFieldPermissions } from './populateFieldPermissions.js'\n\ntype WhereQueryCache = { result: Promise<boolean>; where: Where }[]\n\nexport type BlockReferencesPermissions = Record<\n  BlockSlug,\n  BlockPermissions | Promise<BlockPermissions>\n>\n\nexport type EntityDoc = JsonObject | TypeWithID\n\ntype ReturnType<TEntityType extends 'collection' | 'global'> = TEntityType extends 'global'\n  ? GlobalPermission\n  : CollectionPermission\n\ntype Args<TEntityType extends 'collection' | 'global'> = {\n  blockReferencesPermissions: BlockReferencesPermissions\n  /**\n   * If the document data is passed, it will be used to check access instead of fetching the document from the database.\n   */\n  data?: JsonObject\n  entity: TEntityType extends 'collection' ? SanitizedCollectionConfig : SanitizedGlobalConfig\n  entityType: TEntityType\n  /**\n   * Operations to check access for\n   */\n  operations: AllOperations[]\n  req: PayloadRequest\n} & (\n  | {\n      fetchData: false\n      id?: never\n    }\n  | {\n      fetchData: true\n      id: TEntityType extends 'collection' ? DefaultDocumentIDType : undefined\n    }\n)\n\nconst topLevelCollectionPermissions = [\n  'create',\n  'delete',\n  'read',\n  'readVersions',\n  'update',\n  'unlock',\n]\nconst topLevelGlobalPermissions = ['read', 'readVersions', 'update']\n\n/**\n * Build up permissions object for an entity (collection or global).\n * This is not run during any update and reflects the current state of the entity data => doc and data is the same.\n *\n * When `fetchData` is false:\n * - returned `Where` are not run and evaluated as \"does not have permission\".\n * - If req.data is passed: `data` and `doc` is passed to access functions.\n * - If req.data is not passed: `data` and `doc` is not passed to access functions.\n *\n * When `fetchData` is true:\n * - `Where` are run and evaluated as \"has permission\" or \"does not have permission\".\n * - `data` and `doc` are always passed to access functions.\n * - Error is thrown if `entityType` is 'collection' and `id` is not passed.\n *\n * In both cases:\n * We cannot include siblingData or blockData here, as we do not have siblingData available once we reach block or array\n * rows, as we're calculating schema permissions, which do not include individual rows.\n * For consistency, it's thus better to never include the siblingData and blockData\n *\n * @internal\n */\nexport async function getEntityPermissions<TEntityType extends 'collection' | 'global'>(\n  args: Args<TEntityType>,\n): Promise<ReturnType<TEntityType>> {\n  const {\n    id,\n    blockReferencesPermissions,\n    data: _data,\n    entity,\n    entityType,\n    fetchData,\n    operations,\n    req,\n  } = args\n  const { locale: _locale, user } = req\n\n  const locale = _locale ? _locale : undefined\n\n  if (fetchData && entityType === 'collection' && !id) {\n    throw new Error('ID is required when fetching data for a collection')\n  }\n\n  const hasData = _data && Object.keys(_data).length > 0\n  const data: JsonObject | undefined = hasData\n    ? _data\n    : fetchData\n      ? await (async () => {\n          if (entityType === 'global') {\n            return req.payload.findGlobal({\n              slug: entity.slug,\n              depth: 0,\n              fallbackLocale: null,\n              locale,\n              overrideAccess: true,\n              req,\n            })\n          }\n\n          if (entityType === 'collection') {\n            return req.payload.findByID({\n              id: id!,\n              collection: entity.slug,\n              depth: 0,\n              fallbackLocale: null,\n              locale,\n              overrideAccess: true,\n              req,\n              trash: true,\n            })\n          }\n        })()\n      : undefined\n\n  const isLoggedIn = !!user\n\n  const fieldsPermissions: FieldsPermissions = {}\n\n  const entityPermissions: ReturnType<TEntityType> = {\n    fields: fieldsPermissions,\n  } as ReturnType<TEntityType>\n\n  const promises: Promise<void>[] = []\n\n  // Phase 1: Resolve all access functions to get where queries\n  const accessResults: {\n    operation: keyof typeof entity.access\n    result: Promise<boolean | Where>\n  }[] = []\n\n  for (const _operation of operations) {\n    const operation = _operation as keyof typeof entity.access\n    const accessFunction = entity.access[operation]\n\n    if (\n      (entityType === 'collection' && topLevelCollectionPermissions.includes(operation)) ||\n      (entityType === 'global' && topLevelGlobalPermissions.includes(operation))\n    ) {\n      if (typeof accessFunction === 'function') {\n        accessResults.push({\n          operation,\n          result: Promise.resolve(accessFunction({ id, data, req })) as Promise<boolean | Where>,\n        })\n      } else {\n        entityPermissions[operation] = {\n          permission: isLoggedIn,\n        }\n      }\n    }\n  }\n\n  // Await all access functions in parallel\n  const resolvedAccessResults = await Promise.all(\n    accessResults.map(async (item) => ({\n      operation: item.operation,\n      result: await item.result,\n    })),\n  )\n\n  // Phase 2: Process where queries with cache and resolve in parallel\n  const whereQueryCache: WhereQueryCache = []\n  const wherePromises: Promise<void>[] = []\n\n  for (const { operation, result: accessResult } of resolvedAccessResults) {\n    if (typeof accessResult === 'object') {\n      processWhereQuery({\n        id,\n        slug: entity.slug,\n        accessResult,\n        entityPermissions,\n        entityType,\n        fetchData,\n        locale,\n        operation,\n        req,\n        wherePromises,\n        whereQueryCache,\n      })\n    } else if (entityPermissions[operation]?.permission !== false) {\n      entityPermissions[operation] = { permission: !!accessResult }\n    }\n  }\n\n  // Await all where query DB calls in parallel\n  await Promise.all(wherePromises)\n\n  populateFieldPermissions({\n    blockReferencesPermissions,\n    data,\n    fields: entity.fields,\n    operations,\n    parentPermissionsObject: entityPermissions,\n    permissionsObject: fieldsPermissions,\n    promises,\n    req,\n  })\n\n  /**\n   * Await all promises in parallel.\n   * A promise can add more promises to the promises array (group of fields calls populateFieldPermissions again in their own promise), which will not be\n   * awaited in the first run.\n   * This is why we need to loop again to process the new promises, until there are no more promises left.\n   */\n  let iterations = 0\n  while (promises.length > 0) {\n    const currentPromises = promises.splice(0, promises.length)\n\n    await Promise.all(currentPromises)\n\n    iterations++\n    if (iterations >= 100) {\n      throw new Error('Infinite getEntityPermissions promise loop detected.')\n    }\n  }\n\n  return entityPermissions\n}\n\nconst processWhereQuery = ({\n  id,\n  slug,\n  accessResult,\n  entityPermissions,\n  entityType,\n  fetchData,\n  locale,\n  operation,\n  req,\n  wherePromises,\n  whereQueryCache,\n}: {\n  accessResult: Where\n  entityPermissions: CollectionPermission | GlobalPermission\n  entityType: 'collection' | 'global'\n  fetchData: boolean\n  id?: DefaultDocumentIDType\n  locale?: string\n  operation: Extract<keyof (CollectionPermission | GlobalPermission), AllOperations>\n  req: PayloadRequest\n  slug: string\n  wherePromises: Promise<void>[]\n  whereQueryCache: WhereQueryCache\n}): void => {\n  if (fetchData) {\n    // Check cache for identical where query using deep comparison\n    let cached = whereQueryCache.find((entry) => isDeepStrictEqual(entry.where, accessResult))\n\n    if (!cached) {\n      // Cache miss - start DB query (don't await)\n      cached = {\n        result: entityDocExists({\n          id,\n          slug,\n          entityType,\n          locale,\n          operation,\n          req,\n          where: accessResult,\n        }),\n        where: accessResult,\n      }\n      whereQueryCache.push(cached)\n    }\n\n    // Defer resolution to Promise.all (cache hits reuse same promise)\n    wherePromises.push(\n      cached.result.then((hasPermission) => {\n        entityPermissions[operation] = {\n          permission: hasPermission,\n          where: accessResult,\n        } as Permission\n      }),\n    )\n  } else {\n    // TODO: 4.0: Investigate defaulting to `false` here, if where query is returned but ignored as we don't\n    // have the document data available. This seems more secure.\n    // Alternatively, we could set permission to a third state, like 'unknown'.\n    // Even after calling sanitizePermissions, the permissions will still be true if the where query is returned but ignored as we don't have the document data available.\n    entityPermissions[operation] = { permission: true, where: accessResult } as Permission\n  }\n}\n"],"names":["isDeepStrictEqual","entityDocExists","populateFieldPermissions","topLevelCollectionPermissions","topLevelGlobalPermissions","getEntityPermissions","args","id","blockReferencesPermissions","data","_data","entity","entityType","fetchData","operations","req","locale","_locale","user","undefined","Error","hasData","Object","keys","length","payload","findGlobal","slug","depth","fallbackLocale","overrideAccess","findByID","collection","trash","isLoggedIn","fieldsPermissions","entityPermissions","fields","promises","accessResults","_operation","operation","accessFunction","access","includes","push","result","Promise","resolve","permission","resolvedAccessResults","all","map","item","whereQueryCache","wherePromises","accessResult","processWhereQuery","parentPermissionsObject","permissionsObject","iterations","currentPromises","splice","cached","find","entry","where","then","hasPermission"],"mappings":"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"}

package/dist/utilities/getEntityPermissions/populateFieldPermissions.d.ts

@@ -0,0 +1,24 @@
+import type { CollectionPermission, FieldPermissions, FieldsPermissions, GlobalPermission } from '../../auth/types.js';
+import type { DefaultDocumentIDType } from '../../index.js';
+import type { AllOperations, JsonObject, PayloadRequest } from '../../types/index.js';
+import type { BlockReferencesPermissions } from './getEntityPermissions.js';
+import { type Field } from '../../fields/config/types.js';
+/**
+ * Build up permissions object and run access functions for each field of an entity
+ * This function is synchronous and collects all async work into the promises array
+ */
+export declare const populateFieldPermissions: ({ id, blockReferencesPermissions, data, fields, operations, parentPermissionsObject, permissionsObject, promises, req, }: {
+    blockReferencesPermissions: BlockReferencesPermissions;
+    data: JsonObject | undefined;
+    fields: Field[];
+    id?: DefaultDocumentIDType;
+    /**
+     * Operations to check access for
+     */
+    operations: AllOperations[];
+    parentPermissionsObject: CollectionPermission | FieldPermissions | GlobalPermission;
+    permissionsObject: FieldsPermissions;
+    promises: Promise<void>[];
+    req: PayloadRequest;
+}) => void;
+//# sourceMappingURL=populateFieldPermissions.d.ts.map

package/dist/utilities/getEntityPermissions/populateFieldPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populateFieldPermissions.d.ts","sourceRoot":"","sources":["../../../src/utilities/getEntityPermissions/populateFieldPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAEjB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAE3E,OAAO,EAAE,KAAK,KAAK,EAAc,MAAM,8BAA8B,CAAA;AAkCrE;;;GAGG;AACH,eAAO,MAAM,wBAAwB,6HAUlC;IACD,0BAA0B,EAAE,0BAA0B,CAAA;IACtD,IAAI,EAAE,UAAU,GAAG,SAAS,CAAA;IAC5B,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,EAAE,CAAC,EAAE,qBAAqB,CAAA;IAC1B;;OAEG;IACH,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,uBAAuB,EAAE,oBAAoB,GAAG,gBAAgB,GAAG,gBAAgB,CAAA;IACnF,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,IAsPH,CAAA"}