payload 0.12.5-beta.0 → 0.12.9-beta.0

package/CHANGELOG.md

@@ -1,28 +1,44 @@
-## [0.12.5-beta.0](https://github.com/payloadcms/payload/compare/v0.12.3...v0.12.5-beta.0) (2021-11-01)
+## [0.12.9-beta.0](https://github.com/payloadcms/payload/compare/v0.12.3...v0.12.9-beta.0) (2021-11-24)
 
 
 ### Bug Fixes
 
 * [#351](https://github.com/payloadcms/payload/issues/351) ([94c2b8d](https://github.com/payloadcms/payload/commit/94c2b8d80b046c067057d4ad089ed6a2edd656cf))
 * bug with relationship cell when no doc is available ([40b33d9](https://github.com/payloadcms/payload/commit/40b33d9f5e99285cb0de148dbe059259817fcad8))
+* ensures 'like' query param remains functional in all cases ([20d4e72](https://github.com/payloadcms/payload/commit/20d4e72a951dfcbf1cc301d0938e5095932436b9))
+* ensures buildQuery works with fields as well as simultaneous or / and ([72fc413](https://github.com/payloadcms/payload/commit/72fc413764c6c42ba64a45f01d99b68ad3bd46c4))
 * ensures relationship field search can return more than 10 options ([57c0346](https://github.com/payloadcms/payload/commit/57c0346a00286a3df695ea46e5c2630494183b5b))
+* ensures richtext links retain proper formatting ([abf61d0](https://github.com/payloadcms/payload/commit/abf61d0734c09fd0fc5c5b827cb0631e11701f71))
 * ensures tquerying by relationship subpaths works ([37b21b0](https://github.com/payloadcms/payload/commit/37b21b07628e892e85c2cf979d9e2c8af0d291f7))
+* issue with querying by id and using comma-separated values ([d9e1b5e](https://github.com/payloadcms/payload/commit/d9e1b5ede33616893f9ba6990eeccf5410b75ae1))
+* updates field description type to include react nodes ([291c193](https://github.com/payloadcms/payload/commit/291c193ad4a9ec8ce9310cc63c714eba10eca102))
 
 
 ### Features
 
+* add id fields to generated types ([21a810c](https://github.com/payloadcms/payload/commit/21a810c38c16e6907069d9076abf55718e439497))
+* adds field types to type generation ([6dd1b0e](https://github.com/payloadcms/payload/commit/6dd1b0e0339490bf9e500f03f47ed59381644d85))
+* adds relationship filter field ([463c4e6](https://github.com/payloadcms/payload/commit/463c4e60de8e647fca6268b826d826f9c6e45412))
+* azure cosmos compatibility ([6fd5ac2](https://github.com/payloadcms/payload/commit/6fd5ac2c082a5a5e6f510d781b2a2e12b7b62cb9))
+* baseline type generation ([5a965d2](https://github.com/payloadcms/payload/commit/5a965d2263d1b246149c5220d039a6d97953d5e8))
+* ensures update hooks have access to full original docs even in spite of access control ([b2c5b7e](https://github.com/payloadcms/payload/commit/b2c5b7e5752e829c7a53c054decceb43ec33065e))
+* finishes typing all fields ([ed5a5eb](https://github.com/payloadcms/payload/commit/ed5a5ebe7e16d20577556ab233032a52bef6d2cb))
+* generates further field types ([2ca76ba](https://github.com/payloadcms/payload/commit/2ca76ba8ce6c61ee7b0a01a557b6f013ca483d6d))
 * improves querying logic ([4c85747](https://github.com/payloadcms/payload/commit/4c8574784995b1cb1f939648f4d2158286089b3d))
 
-## [0.12.4-beta.0](https://github.com/payloadcms/payload/compare/v0.12.3...v0.12.4-beta.0) (2021-11-01)
+## [0.12.8-beta.0](https://github.com/payloadcms/payload/compare/v0.12.3...v0.12.8-beta.0) (2021-11-10)
 
 
 ### Bug Fixes
 
-* ensures relationship field search can return more than 10 options ([57c0346](https://github.com/payloadcms/payload/commit/57c0346a00286a3df695ea46e5c2630494183b5b))
-
+* [#351](https://github.com/payloadcms/payload/issues/351) ([94c2b8d](https://github.com/payloadcms/payload/commit/94c2b8d80b046c067057d4ad089ed6a2edd656cf))
+* bug with relationship cell when no doc is available ([40b33d9](https://github.com/payloadcms/payload/commit/40b33d9f5e99285cb0de148dbe059259817fcad8))
+* ensures richtext links retain proper formatting ([abf61d0](https://github.com/payloadcms/payload/commit/abf61d0734c09fd0fc5c5b827cb0631e11701f71))
 
 ### Features
 
+* adds relationship filter field ([463c4e6](https://github.com/payloadcms/payload/commit/463c4e60de8e647fca6268b826d826f9c6e45412))
+* ensures update hooks have access to full original docs even in spite of access control ([b2c5b7e](https://github.com/payloadcms/payload/commit/b2c5b7e5752e829c7a53c054decceb43ec33065e))
 * improves querying logic ([4c85747](https://github.com/payloadcms/payload/commit/4c8574784995b1cb1f939648f4d2158286089b3d))
 
 ## [0.12.3](https://github.com/payloadcms/payload/compare/v0.12.2...v0.12.3) (2021-10-23)

package/dist/admin/components/elements/ReactSelect/index.js

@@ -3,12 +3,12 @@ import Select from 'react-select';
 import Chevron from '../../icons/Chevron';
 import './index.scss';
 const ReactSelect = (props) => {
-    const { className, showError = false, options, onChange, value, disabled = false, } = props;
+    const { className, showError = false, options, onChange, value, disabled = false, placeholder, } = props;
     const classes = [
         className,
         'react-select',
         showError && 'react-select--error',
     ].filter(Boolean).join(' ');
-    return (React.createElement(Select, { ...props, value: value, onChange: onChange, disabled: disabled ? 'disabled' : undefined, components: { DropdownIndicator: Chevron }, className: classes, classNamePrefix: "rs", options: options }));
+    return (React.createElement(Select, { placeholder: placeholder, ...props, value: value, onChange: onChange, disabled: disabled ? 'disabled' : undefined, components: { DropdownIndicator: Chevron }, className: classes, classNamePrefix: "rs", options: options }));
 };
 export default ReactSelect;

package/dist/admin/components/elements/ReactSelect/types.d.ts

@@ -15,4 +15,5 @@ export declare type Props = {
     isDisabled?: boolean;
     onInputChange?: (val: string) => void;
     onMenuScrollToBottom?: () => void;
+    placeholder?: string;
 };

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Props } from './types';
+import './index.scss';
+declare const RelationshipField: React.FC<Props>;
+export default RelationshipField;

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/index.js

@@ -0,0 +1,202 @@
+import React, { useReducer, useState, useCallback, useEffect } from 'react';
+import { useConfig } from '@payloadcms/config-provider';
+import optionsReducer from './optionsReducer';
+import useDebounce from '../../../../../hooks/useDebounce';
+import ReactSelect from '../../../ReactSelect';
+import './index.scss';
+const baseClass = 'condition-value-relationship';
+const maxResultsPerRequest = 10;
+const RelationshipField = (props) => {
+    const { onChange, value, relationTo, hasMany } = props;
+    const { serverURL, routes: { api, }, collections, } = useConfig();
+    const hasMultipleRelations = Array.isArray(relationTo);
+    const [options, dispatchOptions] = useReducer(optionsReducer, []);
+    const [lastFullyLoadedRelation, setLastFullyLoadedRelation] = useState(-1);
+    const [lastLoadedPage, setLastLoadedPage] = useState(1);
+    const [search, setSearch] = useState('');
+    const [errorLoading, setErrorLoading] = useState('');
+    const [hasLoadedFirstOptions, setHasLoadedFirstOptions] = useState(false);
+    const debouncedSearch = useDebounce(search, 300);
+    const addOptions = useCallback((data, relation) => {
+        const collection = collections.find((coll) => coll.slug === relation);
+        dispatchOptions({ type: 'ADD', data, relation, hasMultipleRelations, collection });
+    }, [collections, hasMultipleRelations]);
+    const getResults = useCallback(async ({ lastFullyLoadedRelation: lastFullyLoadedRelationArg, lastLoadedPage: lastLoadedPageArg, search: searchArg, }) => {
+        let lastLoadedPageToUse = typeof lastLoadedPageArg !== 'undefined' ? lastLoadedPageArg : 1;
+        const lastFullyLoadedRelationToUse = typeof lastFullyLoadedRelationArg !== 'undefined' ? lastFullyLoadedRelationArg : -1;
+        const relations = Array.isArray(relationTo) ? relationTo : [relationTo];
+        const relationsToFetch = lastFullyLoadedRelationToUse === -1 ? relations : relations.slice(lastFullyLoadedRelationToUse + 1);
+        let resultsFetched = 0;
+        if (!errorLoading) {
+            relationsToFetch.reduce(async (priorRelation, relation) => {
+                var _a;
+                await priorRelation;
+                if (resultsFetched < 10) {
+                    const collection = collections.find((coll) => coll.slug === relation);
+                    const fieldToSearch = ((_a = collection === null || collection === void 0 ? void 0 : collection.admin) === null || _a === void 0 ? void 0 : _a.useAsTitle) || 'id';
+                    const searchParam = searchArg ? `&where[${fieldToSearch}][like]=${searchArg}` : '';
+                    const response = await fetch(`${serverURL}${api}/${relation}?limit=${maxResultsPerRequest}&page=${lastLoadedPageToUse}&depth=0${searchParam}`);
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.docs.length > 0) {
+                            resultsFetched += data.docs.length;
+                            addOptions(data, relation);
+                            setLastLoadedPage(data.page);
+                            if (!data.nextPage) {
+                                setLastFullyLoadedRelation(relations.indexOf(relation));
+                                // If there are more relations to search, need to reset lastLoadedPage to 1
+                                // both locally within function and state
+                                if (relations.indexOf(relation) + 1 < relations.length) {
+                                    lastLoadedPageToUse = 1;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        setErrorLoading('An error has occurred.');
+                    }
+                }
+            }, Promise.resolve());
+        }
+    }, [addOptions, api, collections, serverURL, errorLoading, relationTo]);
+    const findOptionsByValue = useCallback(() => {
+        if (value) {
+            if (hasMany) {
+                if (Array.isArray(value)) {
+                    return value.map((val) => {
+                        if (hasMultipleRelations) {
+                            let matchedOption;
+                            options.forEach((opt) => {
+                                if (opt.options) {
+                                    opt.options.some((subOpt) => {
+                                        if ((subOpt === null || subOpt === void 0 ? void 0 : subOpt.value) === val.value) {
+                                            matchedOption = subOpt;
+                                            return true;
+                                        }
+                                        return false;
+                                    });
+                                }
+                            });
+                            return matchedOption;
+                        }
+                        return options.find((opt) => opt.value === val);
+                    });
+                }
+                return undefined;
+            }
+            if (hasMultipleRelations) {
+                let matchedOption;
+                const valueWithRelation = value;
+                options.forEach((opt) => {
+                    if (opt === null || opt === void 0 ? void 0 : opt.options) {
+                        opt.options.some((subOpt) => {
+                            if ((subOpt === null || subOpt === void 0 ? void 0 : subOpt.value) === valueWithRelation.value) {
+                                matchedOption = subOpt;
+                                return true;
+                            }
+                            return false;
+                        });
+                    }
+                });
+                return matchedOption;
+            }
+            return options.find((opt) => opt.value === value);
+        }
+        return undefined;
+    }, [hasMany, hasMultipleRelations, value, options]);
+    const handleInputChange = useCallback((newSearch) => {
+        if (search !== newSearch) {
+            setSearch(newSearch);
+        }
+    }, [search]);
+    const addOptionByID = useCallback(async (id, relation) => {
+        if (!errorLoading && id !== 'null') {
+            const response = await fetch(`${serverURL}${api}/${relation}/${id}?depth=0`);
+            if (response.ok) {
+                const data = await response.json();
+                addOptions({ docs: [data] }, relation);
+            }
+            else {
+                console.error(`There was a problem loading the document with ID of ${id}.`);
+            }
+        }
+    }, [addOptions, api, errorLoading, serverURL]);
+    // ///////////////////////////
+    // Get results when search input changes
+    // ///////////////////////////
+    useEffect(() => {
+        dispatchOptions({
+            type: 'CLEAR',
+            required: true,
+        });
+        setHasLoadedFirstOptions(true);
+        setLastLoadedPage(1);
+        setLastFullyLoadedRelation(-1);
+        getResults({ search: debouncedSearch });
+    }, [getResults, debouncedSearch, relationTo]);
+    // ///////////////////////////
+    // Format options once first options have been retrieved
+    // ///////////////////////////
+    useEffect(() => {
+        if (value && hasLoadedFirstOptions) {
+            if (hasMany) {
+                const matchedOptions = findOptionsByValue();
+                (matchedOptions || []).forEach((option, i) => {
+                    if (!option) {
+                        if (hasMultipleRelations) {
+                            addOptionByID(value[i].value, value[i].relationTo);
+                        }
+                        else {
+                            addOptionByID(value[i], relationTo);
+                        }
+                    }
+                });
+            }
+            else {
+                const matchedOption = findOptionsByValue();
+                if (!matchedOption) {
+                    if (hasMultipleRelations) {
+                        const valueWithRelation = value;
+                        addOptionByID(valueWithRelation.value, valueWithRelation.relationTo);
+                    }
+                    else {
+                        addOptionByID(value, relationTo);
+                    }
+                }
+            }
+        }
+    }, [addOptionByID, findOptionsByValue, hasMany, hasMultipleRelations, relationTo, value, hasLoadedFirstOptions]);
+    const classes = [
+        'field-type',
+        baseClass,
+        errorLoading && 'error-loading',
+    ].filter(Boolean).join(' ');
+    const valueToRender = (findOptionsByValue() || value);
+    return (React.createElement("div", { className: classes },
+        !errorLoading && (React.createElement(ReactSelect, { placeholder: "Select a value", onInputChange: handleInputChange, onChange: (selected) => {
+                if (hasMany) {
+                    onChange(selected ? selected.map((option) => {
+                        if (hasMultipleRelations) {
+                            return {
+                                relationTo: option.relationTo,
+                                value: option.value,
+                            };
+                        }
+                        return option.value;
+                    }) : null);
+                }
+                else if (hasMultipleRelations) {
+                    onChange({
+                        relationTo: selected.relationTo,
+                        value: selected.value,
+                    });
+                }
+                else {
+                    onChange(selected.value);
+                }
+            }, onMenuScrollToBottom: () => {
+                getResults({ lastFullyLoadedRelation, lastLoadedPage: lastLoadedPage + 1 });
+            }, value: valueToRender, options: options, isMulti: hasMany })),
+        errorLoading && (React.createElement("div", { className: `${baseClass}__error-loading` }, errorLoading))));
+};
+export default RelationshipField;

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/index.scss

@@ -0,0 +1,11 @@
+@import '../../../../../scss/styles.scss';
+
+.condition-value-relationship {
+  &__error-loading {
+    border: 1px solid $color-red;
+    min-height: base(2);
+    padding: base(.5) base(.75);
+    background-color: $color-red;
+    color: white;
+  }
+}

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/optionsReducer.d.ts

@@ -0,0 +1,3 @@
+import { Option, Action } from './types';
+declare const optionsReducer: (state: Option[], action: Action) => Option[];
+export default optionsReducer;

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/optionsReducer.js

@@ -0,0 +1,76 @@
+const reduceToIDs = (options) => options.reduce((ids, option) => {
+    if (option.options) {
+        return [
+            ...ids,
+            ...reduceToIDs(option.options),
+        ];
+    }
+    return [
+        ...ids,
+        option.id,
+    ];
+}, []);
+const optionsReducer = (state, action) => {
+    switch (action.type) {
+        case 'CLEAR': {
+            return action.required ? [] : [{ value: 'null', label: 'None' }];
+        }
+        case 'ADD': {
+            const { hasMultipleRelations, collection, relation, data } = action;
+            const labelKey = collection.admin.useAsTitle || 'id';
+            const loadedIDs = reduceToIDs(state);
+            if (!hasMultipleRelations) {
+                return [
+                    ...state,
+                    ...data.docs.reduce((docs, doc) => {
+                        if (loadedIDs.indexOf(doc.id) === -1) {
+                            loadedIDs.push(doc.id);
+                            return [
+                                ...docs,
+                                {
+                                    label: doc[labelKey],
+                                    value: doc.id,
+                                },
+                            ];
+                        }
+                        return docs;
+                    }, []),
+                ];
+            }
+            const newOptions = [...state];
+            const optionsToAddTo = newOptions.find((optionGroup) => optionGroup.label === collection.labels.plural);
+            const newSubOptions = data.docs.reduce((docs, doc) => {
+                if (loadedIDs.indexOf(doc.id) === -1) {
+                    loadedIDs.push(doc.id);
+                    return [
+                        ...docs,
+                        {
+                            label: doc[labelKey],
+                            relationTo: relation,
+                            value: doc.id,
+                        },
+                    ];
+                }
+                return docs;
+            }, []);
+            if (optionsToAddTo) {
+                optionsToAddTo.options = [
+                    ...optionsToAddTo.options,
+                    ...newSubOptions,
+                ];
+            }
+            else {
+                newOptions.push({
+                    label: collection.labels.plural,
+                    options: newSubOptions,
+                    value: undefined,
+                });
+            }
+            return newOptions;
+        }
+        default: {
+            return state;
+        }
+    }
+};
+export default optionsReducer;

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/types.d.ts

@@ -0,0 +1,29 @@
+import { RelationshipField } from '../../../../../../fields/config/types';
+import { PaginatedDocs, SanitizedCollectionConfig } from '../../../../../../collections/config/types';
+export declare type Props = {
+    onChange: (val: unknown) => void;
+    value: unknown;
+} & RelationshipField;
+export declare type Option = {
+    label: string;
+    value: string;
+    relationTo?: string;
+    options?: Option[];
+};
+declare type CLEAR = {
+    type: 'CLEAR';
+    required: boolean;
+};
+declare type ADD = {
+    type: 'ADD';
+    data: PaginatedDocs;
+    relation: string;
+    hasMultipleRelations: boolean;
+    collection: SanitizedCollectionConfig;
+};
+export declare type Action = CLEAR | ADD;
+export declare type ValueWithRelation = {
+    relationTo: string;
+    value: string;
+};
+export {};

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/types.js

@@ -0,0 +1 @@
+export {};

package/dist/admin/components/elements/WhereBuilder/Condition/index.js

@@ -5,12 +5,14 @@ import Button from '../../Button';
 import Date from './Date';
 import Number from './Number';
 import Text from './Text';
+import Relationship from './Relationship';
 import useDebounce from '../../../../hooks/useDebounce';
 import './index.scss';
 const valueFields = {
     Date,
     Number,
     Text,
+    Relationship,
 };
 const baseClass = 'condition';
 const Condition = (props) => {
@@ -60,6 +62,7 @@ const Condition = (props) => {
                 React.createElement("div", { className: `${baseClass}__value` },
                     React.createElement(RenderCustomComponent, { CustomComponent: (_c = (_b = (_a = activeField === null || activeField === void 0 ? void 0 : activeField.props) === null || _a === void 0 ? void 0 : _a.admin) === null || _b === void 0 ? void 0 : _b.components) === null || _c === void 0 ? void 0 : _c.Filter, DefaultComponent: ValueComponent, componentProps: {
                             ...activeField === null || activeField === void 0 ? void 0 : activeField.props,
+                            operator: operatorValue,
                             value: internalValue,
                             onChange: setInternalValue,
                         } }))),

package/dist/admin/components/elements/WhereBuilder/field-types.js

@@ -95,7 +95,7 @@ const fieldTypeConditions = {
         operators: [...base],
     },
     relationship: {
-        component: 'Text',
+        component: 'Relationship',
         operators: [...base],
     },
     select: {

package/dist/admin/components/forms/FieldDescription/types.d.ts

@@ -3,10 +3,9 @@ export declare type DescriptionFunction = (value: unknown) => string;
 export declare type DescriptionComponent = React.ComponentType<{
     value: unknown;
 }>;
-declare type Description = string | DescriptionFunction | DescriptionComponent;
+export declare type Description = string | DescriptionFunction | DescriptionComponent;
 export declare type Props = {
     description?: Description;
     value: unknown;
 };
 export declare function isComponent(description: Description): description is DescriptionComponent;
-export {};

package/dist/admin/components/forms/FieldDescription/types.js

@@ -1,4 +1,12 @@
-import React from 'react';
-export function isComponent(description) {
-    return React.isValidElement(description);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComponent = void 0;
+const react_1 = __importDefault(require("react"));
+function isComponent(description) {
+    return react_1.default.isValidElement(description);
 }
+exports.isComponent = isComponent;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYWRtaW4vY29tcG9uZW50cy9mb3Jtcy9GaWVsZERlc2NyaXB0aW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUEwQjtBQWExQixTQUFnQixXQUFXLENBQUMsV0FBd0I7SUFDbEQsT0FBTyxlQUFLLENBQUMsY0FBYyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0FBQzNDLENBQUM7QUFGRCxrQ0FFQyJ9

package/dist/admin/components/forms/field-types/Array/types.d.ts

@@ -1,7 +1,8 @@
 import { Data } from '../../Form/types';
-import { ArrayField, Labels, Field, Description } from '../../../../../fields/config/types';
+import { ArrayField, Labels, Field } from '../../../../../fields/config/types';
 import { FieldTypes } from '..';
 import { FieldPermissions } from '../../../../../auth/types';
+import { Description } from '../../FieldDescription/types';
 export declare type Props = Omit<ArrayField, 'type'> & {
     path?: string;
     fieldTypes: FieldTypes;

package/dist/admin/components/forms/field-types/Blocks/types.d.ts

@@ -1,7 +1,8 @@
 import { Data } from '../../Form/types';
-import { BlockField, Labels, Block, Description } from '../../../../../fields/config/types';
+import { BlockField, Labels, Block } from '../../../../../fields/config/types';
 import { FieldTypes } from '..';
 import { FieldPermissions } from '../../../../../auth/types';
+import { Description } from '../../FieldDescription/types';
 export declare type Props = Omit<BlockField, 'type'> & {
     path?: string;
     fieldTypes: FieldTypes;

package/dist/admin/components/forms/field-types/Password/types.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
-import { Description, Validate } from '../../../../../fields/config/types';
+import { Validate } from '../../../../../fields/config/types';
+import { Description } from '../../FieldDescription/types';
 export declare type Props = {
     autoComplete?: string;
     path?: string;

package/dist/admin/components/forms/field-types/RichText/elements/link/index.scss

@@ -23,6 +23,11 @@
 
 .rich-text-link__button {
   @extend %btn-reset;
+  font-size: inherit;
+  font-weight: inherit;
+  color: inherit;
+  letter-spacing: inherit;
+  line-height: inherit;
   position: relative;
   z-index: 2;
   text-decoration: underline;

package/dist/bin/generateTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateTypes(): void;