@payloadcms/graphql 3.0.0-alpha.0

package/dist/schema/buildPaginatedListType.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _graphql = require("graphql");
+const buildPaginatedListType = (name, docType)=>new _graphql.GraphQLObjectType({
+        name,
+        fields: {
+            docs: {
+                type: new _graphql.GraphQLList(docType)
+            },
+            hasNextPage: {
+                type: _graphql.GraphQLBoolean
+            },
+            hasPrevPage: {
+                type: _graphql.GraphQLBoolean
+            },
+            limit: {
+                type: _graphql.GraphQLInt
+            },
+            nextPage: {
+                type: _graphql.GraphQLInt
+            },
+            offset: {
+                type: _graphql.GraphQLInt
+            },
+            page: {
+                type: _graphql.GraphQLInt
+            },
+            pagingCounter: {
+                type: _graphql.GraphQLInt
+            },
+            prevPage: {
+                type: _graphql.GraphQLInt
+            },
+            totalDocs: {
+                type: _graphql.GraphQLInt
+            },
+            totalPages: {
+                type: _graphql.GraphQLInt
+            }
+        }
+    });
+const _default = buildPaginatedListType;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/schema/buildPoliciesType.d.ts

@@ -0,0 +1,29 @@
+import { GraphQLObjectType } from 'graphql';
+import type { CollectionConfig, Field, GlobalConfig, SanitizedConfig } from 'payload/types';
+type OperationType = 'create' | 'delete' | 'read' | 'readVersions' | 'unlock' | 'update';
+type AccessScopes = 'docAccess' | undefined;
+type BuildEntityPolicy = {
+    entityFields: Field[];
+    name: string;
+    operations: OperationType[];
+    scope: AccessScopes;
+};
+export declare const buildEntityPolicy: (args: BuildEntityPolicy) => {
+    fields: {
+        type: GraphQLObjectType<any, any>;
+    };
+};
+type BuildPolicyType = {
+    scope?: AccessScopes;
+    typeSuffix?: string;
+} & ({
+    entity: CollectionConfig;
+    type: 'collection';
+} | {
+    entity: GlobalConfig;
+    type: 'global';
+});
+export declare function buildPolicyType(args: BuildPolicyType): GraphQLObjectType;
+export default function buildPoliciesType(config: SanitizedConfig): GraphQLObjectType;
+export {};
+//# sourceMappingURL=buildPoliciesType.d.ts.map

package/dist/schema/buildPoliciesType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildPoliciesType.d.ts","sourceRoot":"","sources":["../../src/schema/buildPoliciesType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,EACV,gBAAgB,EAEhB,KAAK,EACL,YAAY,EAEZ,eAAe,EAChB,MAAM,eAAe,CAAA;AAKtB,KAAK,aAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAExF,KAAK,YAAY,GAAG,WAAW,GAAG,SAAS,CAAA;AA8E3C,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,KAAK,EAAE,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,KAAK,EAAE,YAAY,CAAA;CACpB,CAAA;AACD,eAAO,MAAM,iBAAiB,SAAU,iBAAiB;;;;CA4BxD,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,GAAG,CACA;IACE,MAAM,EAAE,gBAAgB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,QAAQ,CAAA;CACf,CACJ,CAAA;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,iBAAiB,CAuDxE;AAED,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,iBAAiB,CAyCpF"}

package/dist/schema/buildPoliciesType.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildEntityPolicy: function() {
+        return buildEntityPolicy;
+    },
+    buildPolicyType: function() {
+        return buildPolicyType;
+    },
+    default: function() {
+        return buildPoliciesType;
+    }
+});
+const _graphql = require("graphql");
+const _graphqltypejson = require("graphql-type-json");
+const _utilities = require("payload/utilities");
+const _formatName = /*#__PURE__*/ _interop_require_default(require("../utilities/formatName"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const buildFields = (label, fieldsToBuild)=>fieldsToBuild.reduce((builtFields, field)=>{
+        const includeField = !field.hidden && field.type !== 'ui';
+        if (includeField) {
+            if (field.name) {
+                const fieldName = (0, _formatName.default)(field.name);
+                const objectTypeFields = [
+                    'create',
+                    'read',
+                    'update',
+                    'delete'
+                ].reduce((operations, operation)=>{
+                    const capitalizedOperation = operation.charAt(0).toUpperCase() + operation.slice(1);
+                    return {
+                        ...operations,
+                        [operation]: {
+                            type: new _graphql.GraphQLObjectType({
+                                name: `${label}_${fieldName}_${capitalizedOperation}`,
+                                fields: {
+                                    permission: {
+                                        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+                                    }
+                                }
+                            })
+                        }
+                    };
+                }, {});
+                if (field.fields) {
+                    objectTypeFields.fields = {
+                        type: new _graphql.GraphQLObjectType({
+                            name: `${label}_${fieldName}_Fields`,
+                            fields: buildFields(`${label}_${fieldName}`, field.fields)
+                        })
+                    };
+                }
+                return {
+                    ...builtFields,
+                    [field.name]: {
+                        type: new _graphql.GraphQLObjectType({
+                            name: `${label}_${fieldName}`,
+                            fields: objectTypeFields
+                        })
+                    }
+                };
+            }
+            if (!field.name && field.fields) {
+                const subFields = buildFields(label, field.fields);
+                return {
+                    ...builtFields,
+                    ...subFields
+                };
+            }
+            if (field.type === 'tabs') {
+                return field.tabs.reduce((fieldsWithTabFields, tab)=>{
+                    return {
+                        ...fieldsWithTabFields,
+                        ...buildFields(label, tab.fields)
+                    };
+                }, {
+                    ...builtFields
+                });
+            }
+        }
+        return builtFields;
+    }, {});
+const buildEntityPolicy = (args)=>{
+    const { name, entityFields, operations, scope } = args;
+    const fieldsTypeName = (0, _utilities.toWords)(`${name}-${scope || ''}-Fields`, true);
+    const fields = {
+        fields: {
+            type: new _graphql.GraphQLObjectType({
+                name: fieldsTypeName,
+                fields: buildFields(fieldsTypeName, entityFields)
+            })
+        }
+    };
+    operations.forEach((operation)=>{
+        const operationTypeName = (0, _utilities.toWords)(`${name}-${operation}-${scope || 'Access'}`, true);
+        fields[operation] = {
+            type: new _graphql.GraphQLObjectType({
+                name: operationTypeName,
+                fields: {
+                    permission: {
+                        type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+                    },
+                    where: {
+                        type: _graphqltypejson.GraphQLJSONObject
+                    }
+                }
+            })
+        };
+    });
+    return fields;
+};
+function buildPolicyType(args) {
+    const { entity, scope, type, typeSuffix } = args;
+    const { fields, graphQL, slug, versions } = entity;
+    let operations = [];
+    if (graphQL === false) return null;
+    if (type === 'collection') {
+        operations = [
+            'create',
+            'read',
+            'update',
+            'delete'
+        ];
+        if (entity.auth && typeof entity.auth === 'object' && typeof entity.auth.maxLoginAttempts !== 'undefined' && entity.auth.maxLoginAttempts !== 0) {
+            operations.push('unlock');
+        }
+        if (versions) {
+            operations.push('readVersions');
+        }
+        const collectionTypeName = (0, _formatName.default)(`${slug}${typeSuffix || ''}`);
+        return new _graphql.GraphQLObjectType({
+            name: collectionTypeName,
+            fields: buildEntityPolicy({
+                name: slug,
+                entityFields: fields,
+                operations,
+                scope
+            })
+        });
+    }
+    // else create global type
+    operations = [
+        'read',
+        'update'
+    ];
+    if (entity.versions) {
+        operations.push('readVersions');
+    }
+    const globalTypeName = (0, _formatName.default)(`${global?.graphQL?.name || slug}${typeSuffix || ''}`);
+    return new _graphql.GraphQLObjectType({
+        name: globalTypeName,
+        fields: buildEntityPolicy({
+            name: entity.graphQL ? entity?.graphQL?.name || slug : slug,
+            entityFields: entity.fields,
+            operations,
+            scope
+        })
+    });
+}
+function buildPoliciesType(config) {
+    const fields = {
+        canAccessAdmin: {
+            type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+        }
+    };
+    Object.values(config.collections).forEach((collection)=>{
+        if (collection.graphQL === false) {
+            return;
+        }
+        const collectionPolicyType = buildPolicyType({
+            entity: collection,
+            type: 'collection',
+            typeSuffix: 'Access'
+        });
+        fields[(0, _formatName.default)(collection.slug)] = {
+            type: collectionPolicyType
+        };
+    });
+    Object.values(config.globals).forEach((global1)=>{
+        if (global1.graphQL === false) {
+            return;
+        }
+        const globalPolicyType = buildPolicyType({
+            entity: global1,
+            type: 'global',
+            typeSuffix: 'Access'
+        });
+        fields[(0, _formatName.default)(global1.slug)] = {
+            type: globalPolicyType
+        };
+    });
+    return new _graphql.GraphQLObjectType({
+        name: 'Access',
+        fields
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/schema/buildPoliciesType.ts"],"sourcesContent":["import { GraphQLBoolean, GraphQLNonNull, GraphQLObjectType } from 'graphql'\nimport { GraphQLJSONObject } from 'graphql-type-json'\nimport type {\n  CollectionConfig,\n  SanitizedCollectionConfig,\n  Field,\n  GlobalConfig,\n  SanitizedGlobalConfig,\n  SanitizedConfig,\n} from 'payload/types'\n\nimport { toWords } from 'payload/utilities'\nimport formatName from '../utilities/formatName'\n\ntype OperationType = 'create' | 'delete' | 'read' | 'readVersions' | 'unlock' | 'update'\n\ntype AccessScopes = 'docAccess' | undefined\n\ntype ObjectTypeFields = {\n  [key in 'fields' | OperationType]?: { type: GraphQLObjectType }\n}\n\nconst buildFields = (label, fieldsToBuild) =>\n  fieldsToBuild.reduce((builtFields, field) => {\n    const includeField = !field.hidden && field.type !== 'ui'\n    if (includeField) {\n      if (field.name) {\n        const fieldName = formatName(field.name)\n\n        const objectTypeFields: ObjectTypeFields = ['create', 'read', 'update', 'delete'].reduce(\n          (operations, operation) => {\n            const capitalizedOperation = operation.charAt(0).toUpperCase() + operation.slice(1)\n\n            return {\n              ...operations,\n              [operation]: {\n                type: new GraphQLObjectType({\n                  name: `${label}_${fieldName}_${capitalizedOperation}`,\n                  fields: {\n                    permission: {\n                      type: new GraphQLNonNull(GraphQLBoolean),\n                    },\n                  },\n                }),\n              },\n            }\n          },\n          {},\n        )\n\n        if (field.fields) {\n          objectTypeFields.fields = {\n            type: new GraphQLObjectType({\n              name: `${label}_${fieldName}_Fields`,\n              fields: buildFields(`${label}_${fieldName}`, field.fields),\n            }),\n          }\n        }\n\n        return {\n          ...builtFields,\n          [field.name]: {\n            type: new GraphQLObjectType({\n              name: `${label}_${fieldName}`,\n              fields: objectTypeFields,\n            }),\n          },\n        }\n      }\n\n      if (!field.name && field.fields) {\n        const subFields = buildFields(label, field.fields)\n\n        return {\n          ...builtFields,\n          ...subFields,\n        }\n      }\n\n      if (field.type === 'tabs') {\n        return field.tabs.reduce(\n          (fieldsWithTabFields, tab) => {\n            return {\n              ...fieldsWithTabFields,\n              ...buildFields(label, tab.fields),\n            }\n          },\n          { ...builtFields },\n        )\n      }\n    }\n    return builtFields\n  }, {})\n\ntype BuildEntityPolicy = {\n  entityFields: Field[]\n  name: string\n  operations: OperationType[]\n  scope: AccessScopes\n}\nexport const buildEntityPolicy = (args: BuildEntityPolicy) => {\n  const { name, entityFields, operations, scope } = args\n\n  const fieldsTypeName = toWords(`${name}-${scope || ''}-Fields`, true)\n  const fields = {\n    fields: {\n      type: new GraphQLObjectType({\n        name: fieldsTypeName,\n        fields: buildFields(fieldsTypeName, entityFields),\n      }),\n    },\n  }\n\n  operations.forEach((operation) => {\n    const operationTypeName = toWords(`${name}-${operation}-${scope || 'Access'}`, true)\n\n    fields[operation] = {\n      type: new GraphQLObjectType({\n        name: operationTypeName,\n        fields: {\n          permission: { type: new GraphQLNonNull(GraphQLBoolean) },\n          where: { type: GraphQLJSONObject },\n        },\n      }),\n    }\n  })\n\n  return fields\n}\n\ntype BuildPolicyType = {\n  scope?: AccessScopes\n  typeSuffix?: string\n} & (\n  | {\n      entity: CollectionConfig\n      type: 'collection'\n    }\n  | {\n      entity: GlobalConfig\n      type: 'global'\n    }\n)\nexport function buildPolicyType(args: BuildPolicyType): GraphQLObjectType {\n  const { entity, scope, type, typeSuffix } = args\n  const { fields, graphQL, slug, versions } = entity\n\n  let operations = []\n\n  if (graphQL === false) return null\n\n  if (type === 'collection') {\n    operations = ['create', 'read', 'update', 'delete']\n\n    if (\n      entity.auth &&\n      typeof entity.auth === 'object' &&\n      typeof entity.auth.maxLoginAttempts !== 'undefined' &&\n      entity.auth.maxLoginAttempts !== 0\n    ) {\n      operations.push('unlock')\n    }\n\n    if (versions) {\n      operations.push('readVersions')\n    }\n\n    const collectionTypeName = formatName(`${slug}${typeSuffix || ''}`)\n\n    return new GraphQLObjectType({\n      name: collectionTypeName,\n      fields: buildEntityPolicy({\n        name: slug,\n        entityFields: fields,\n        operations,\n        scope,\n      }),\n    })\n  }\n\n  // else create global type\n  operations = ['read', 'update']\n\n  if (entity.versions) {\n    operations.push('readVersions')\n  }\n\n  const globalTypeName = formatName(`${global?.graphQL?.name || slug}${typeSuffix || ''}`)\n\n  return new GraphQLObjectType({\n    name: globalTypeName,\n    fields: buildEntityPolicy({\n      name: entity.graphQL ? entity?.graphQL?.name || slug : slug,\n      entityFields: entity.fields,\n      operations,\n      scope,\n    }),\n  })\n}\n\nexport default function buildPoliciesType(config: SanitizedConfig): GraphQLObjectType {\n  const fields = {\n    canAccessAdmin: {\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  }\n\n  Object.values(config.collections).forEach((collection: SanitizedCollectionConfig) => {\n    if (collection.graphQL === false) {\n      return\n    }\n    const collectionPolicyType = buildPolicyType({\n      entity: collection,\n      type: 'collection',\n      typeSuffix: 'Access',\n    })\n\n    fields[formatName(collection.slug)] = {\n      type: collectionPolicyType,\n    }\n  })\n\n  Object.values(config.globals).forEach((global: SanitizedGlobalConfig) => {\n    if (global.graphQL === false) {\n      return\n    }\n    const globalPolicyType = buildPolicyType({\n      entity: global,\n      type: 'global',\n      typeSuffix: 'Access',\n    })\n\n    fields[formatName(global.slug)] = {\n      type: globalPolicyType,\n    }\n  })\n\n  return new GraphQLObjectType({\n    name: 'Access',\n    fields,\n  })\n}\n"],"names":["buildEntityPolicy","buildPolicyType","buildPoliciesType","buildFields","label","fieldsToBuild","reduce","builtFields","field","includeField","hidden","type","name","fieldName","formatName","objectTypeFields","operations","operation","capitalizedOperation","charAt","toUpperCase","slice","GraphQLObjectType","fields","permission","GraphQLNonNull","GraphQLBoolean","subFields","tabs","fieldsWithTabFields","tab","args","entityFields","scope","fieldsTypeName","toWords","forEach","operationTypeName","where","GraphQLJSONObject","entity","typeSuffix","graphQL","slug","versions","auth","maxLoginAttempts","push","collectionTypeName","globalTypeName","global","config","canAccessAdmin","Object","values","collections","collection","collectionPolicyType","globals","globalPolicyType"],"mappings":"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"}

package/dist/schema/buildWhereInputType.d.ts

@@ -0,0 +1,24 @@
+import { GraphQLInputObjectType } from 'graphql';
+import type { Field } from 'payload/types';
+type Args = {
+    fields: Field[];
+    name: string;
+    parentName: string;
+};
+/** This does as the function name suggests. It builds a where GraphQL input type
+ * for all the fields which are passed to the function.
+ * Each field has different operators which may be valid for a where input type.
+ * For example, a text field may have a "contains" operator, but a number field
+ * may not.
+ *
+ * buildWhereInputType is similar to buildObjectType and operates
+ * on a field basis with a few distinct differences.
+ *
+ * 1. Everything needs to be a GraphQLInputObjectType or scalar / enum
+ * 2. Relationships, groups, repeaters and flex content are not
+ *    directly searchable. Instead, we need to build a chained pathname
+ *    using dot notation so MongoDB can properly search nested paths.
+ */
+declare const buildWhereInputType: ({ name, fields, parentName }: Args) => GraphQLInputObjectType;
+export default buildWhereInputType;
+//# sourceMappingURL=buildWhereInputType.d.ts.map

package/dist/schema/buildWhereInputType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildWhereInputType.d.ts","sourceRoot":"","sources":["../../src/schema/buildWhereInputType.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAe,MAAM,SAAS,CAAA;AAE7D,OAAO,KAAK,EAAE,KAAK,EAAsB,MAAM,eAAe,CAAA;AAQ9D,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,mBAAmB,iCAAkC,IAAI,KAAG,sBAgFjE,CAAA;AAED,eAAe,mBAAmB,CAAA"}

package/dist/schema/buildWhereInputType.js

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */ /* eslint-disable no-use-before-define */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _graphql = require("graphql");
+const _types = require("payload/types");
+const _formatName = /*#__PURE__*/ _interop_require_default(require("../utilities/formatName"));
+const _fieldToWhereInputSchemaMap = /*#__PURE__*/ _interop_require_default(require("./fieldToWhereInputSchemaMap"));
+const _withOperators = require("./withOperators");
+const _utilities = require("payload/utilities");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** This does as the function name suggests. It builds a where GraphQL input type
+ * for all the fields which are passed to the function.
+ * Each field has different operators which may be valid for a where input type.
+ * For example, a text field may have a "contains" operator, but a number field
+ * may not.
+ *
+ * buildWhereInputType is similar to buildObjectType and operates
+ * on a field basis with a few distinct differences.
+ *
+ * 1. Everything needs to be a GraphQLInputObjectType or scalar / enum
+ * 2. Relationships, groups, repeaters and flex content are not
+ *    directly searchable. Instead, we need to build a chained pathname
+ *    using dot notation so MongoDB can properly search nested paths.
+ */ const buildWhereInputType = ({ name, fields, parentName })=>{
+    // This is the function that builds nested paths for all
+    // field types with nested paths.
+    const idField = (0, _utilities.flattenTopLevelFields)(fields).find((field)=>(0, _types.fieldAffectsData)(field) && field.name === 'id');
+    const fieldTypes = fields.reduce((schema, field)=>{
+        if (!(0, _types.fieldIsPresentationalOnly)(field) && !field.hidden) {
+            const getFieldSchema = (0, _fieldToWhereInputSchemaMap.default)({
+                parentName
+            })[field.type];
+            if (getFieldSchema) {
+                const fieldSchema = getFieldSchema(field);
+                if ((0, _types.fieldHasSubFields)(field) || field.type === 'tabs') {
+                    return {
+                        ...schema,
+                        ...fieldSchema.reduce((subFields, subField)=>({
+                                ...subFields,
+                                [(0, _formatName.default)(subField.key)]: subField.type
+                            }), {})
+                    };
+                }
+                return {
+                    ...schema,
+                    [(0, _formatName.default)(field.name)]: fieldSchema
+                };
+            }
+        }
+        return schema;
+    }, {});
+    if (!idField) {
+        fieldTypes.id = {
+            type: (0, _withOperators.withOperators)({
+                name: 'id',
+                type: 'text'
+            }, parentName)
+        };
+    }
+    const fieldName = (0, _formatName.default)(name);
+    const recursiveFields = {
+        AND: {
+            type: new _graphql.GraphQLList(new _graphql.GraphQLInputObjectType({
+                name: `${fieldName}_where_and`,
+                fields: ()=>({
+                        ...fieldTypes,
+                        ...recursiveFields
+                    })
+            }))
+        },
+        OR: {
+            type: new _graphql.GraphQLList(new _graphql.GraphQLInputObjectType({
+                name: `${fieldName}_where_or`,
+                fields: ()=>({
+                        ...fieldTypes,
+                        ...recursiveFields
+                    })
+            }))
+        }
+    };
+    return new _graphql.GraphQLInputObjectType({
+        name: `${fieldName}_where`,
+        fields: {
+            ...fieldTypes,
+            ...recursiveFields
+        }
+    });
+};
+const _default = buildWhereInputType;
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/schema/fieldToWhereInputSchemaMap.d.ts

@@ -0,0 +1,7 @@
+type Args = {
+    nestedFieldName?: string;
+    parentName: string;
+};
+declare const fieldToSchemaMap: ({ nestedFieldName, parentName }: Args) => any;
+export default fieldToSchemaMap;
+//# sourceMappingURL=fieldToWhereInputSchemaMap.d.ts.map

package/dist/schema/fieldToWhereInputSchemaMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldToWhereInputSchemaMap.d.ts","sourceRoot":"","sources":["../../src/schema/fieldToWhereInputSchemaMap.ts"],"names":[],"mappings":"AA8BA,KAAK,IAAI,GAAG;IACV,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,QAAA,MAAM,gBAAgB,oCAAqC,IAAI,KAAG,GAoGhE,CAAA;AAEF,eAAe,gBAAgB,CAAA"}

package/dist/schema/fieldToWhereInputSchemaMap.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _graphql = require("graphql");
+const _graphqltypejson = /*#__PURE__*/ _interop_require_default(require("graphql-type-json"));
+const _combineParentName = /*#__PURE__*/ _interop_require_default(require("../utilities/combineParentName"));
+const _formatName = /*#__PURE__*/ _interop_require_default(require("../utilities/formatName"));
+const _recursivelyBuildNestedPaths = /*#__PURE__*/ _interop_require_default(require("./recursivelyBuildNestedPaths"));
+const _withOperators = require("./withOperators");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const fieldToSchemaMap = ({ nestedFieldName, parentName })=>({
+        array: (field)=>(0, _recursivelyBuildNestedPaths.default)({
+                field,
+                nestedFieldName2: nestedFieldName,
+                parentName
+            }),
+        checkbox: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        code: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        collapsible: (field)=>(0, _recursivelyBuildNestedPaths.default)({
+                field,
+                nestedFieldName2: nestedFieldName,
+                parentName
+            }),
+        date: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        email: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        group: (field)=>(0, _recursivelyBuildNestedPaths.default)({
+                field,
+                nestedFieldName2: nestedFieldName,
+                parentName
+            }),
+        json: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        number: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        point: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        radio: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        relationship: (field)=>{
+            if (Array.isArray(field.relationTo)) {
+                return {
+                    type: new _graphql.GraphQLInputObjectType({
+                        name: `${(0, _combineParentName.default)(parentName, field.name)}_Relation`,
+                        fields: {
+                            relationTo: {
+                                type: new _graphql.GraphQLEnumType({
+                                    name: `${(0, _combineParentName.default)(parentName, field.name)}_Relation_RelationTo`,
+                                    values: field.relationTo.reduce((values, relation)=>({
+                                            ...values,
+                                            [(0, _formatName.default)(relation)]: {
+                                                value: relation
+                                            }
+                                        }), {})
+                                })
+                            },
+                            value: {
+                                type: _graphqltypejson.default
+                            }
+                        }
+                    })
+                };
+            }
+            return {
+                type: (0, _withOperators.withOperators)(field, parentName)
+            };
+        },
+        richText: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        row: (field)=>(0, _recursivelyBuildNestedPaths.default)({
+                field,
+                nestedFieldName2: nestedFieldName,
+                parentName
+            }),
+        select: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        tabs: (field)=>(0, _recursivelyBuildNestedPaths.default)({
+                field,
+                nestedFieldName2: nestedFieldName,
+                parentName
+            }),
+        text: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        textarea: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            }),
+        upload: (field)=>({
+                type: (0, _withOperators.withOperators)(field, parentName)
+            })
+    });
+const _default = fieldToSchemaMap;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/schema/fieldToWhereInputSchemaMap.ts"],"sourcesContent":["import { GraphQLEnumType, GraphQLInputObjectType } from 'graphql'\nimport GraphQLJSON from 'graphql-type-json'\n\nimport type {\n  ArrayField,\n  CheckboxField,\n  CodeField,\n  CollapsibleField,\n  DateField,\n  EmailField,\n  GroupField,\n  JSONField,\n  NumberField,\n  PointField,\n  RadioField,\n  RelationshipField,\n  RichTextField,\n  RowField,\n  SelectField,\n  TabsField,\n  TextField,\n  TextareaField,\n  UploadField,\n} from 'payload/types'\n\nimport combineParentName from '../utilities/combineParentName'\nimport formatName from '../utilities/formatName'\nimport recursivelyBuildNestedPaths from './recursivelyBuildNestedPaths'\nimport { withOperators } from './withOperators'\n\ntype Args = {\n  nestedFieldName?: string\n  parentName: string\n}\n\nconst fieldToSchemaMap = ({ nestedFieldName, parentName }: Args): any => ({\n  array: (field: ArrayField) =>\n    recursivelyBuildNestedPaths({\n      field,\n      nestedFieldName2: nestedFieldName,\n      parentName,\n    }),\n  checkbox: (field: CheckboxField) => ({\n    type: withOperators(field, parentName),\n  }),\n  code: (field: CodeField) => ({\n    type: withOperators(field, parentName),\n  }),\n  collapsible: (field: CollapsibleField) =>\n    recursivelyBuildNestedPaths({\n      field,\n      nestedFieldName2: nestedFieldName,\n      parentName,\n    }),\n  date: (field: DateField) => ({\n    type: withOperators(field, parentName),\n  }),\n  email: (field: EmailField) => ({\n    type: withOperators(field, parentName),\n  }),\n  group: (field: GroupField) =>\n    recursivelyBuildNestedPaths({\n      field,\n      nestedFieldName2: nestedFieldName,\n      parentName,\n    }),\n  json: (field: JSONField) => ({\n    type: withOperators(field, parentName),\n  }),\n  number: (field: NumberField) => ({\n    type: withOperators(field, parentName),\n  }),\n  point: (field: PointField) => ({\n    type: withOperators(field, parentName),\n  }),\n  radio: (field: RadioField) => ({\n    type: withOperators(field, parentName),\n  }),\n  relationship: (field: RelationshipField) => {\n    if (Array.isArray(field.relationTo)) {\n      return {\n        type: new GraphQLInputObjectType({\n          name: `${combineParentName(parentName, field.name)}_Relation`,\n          fields: {\n            relationTo: {\n              type: new GraphQLEnumType({\n                name: `${combineParentName(parentName, field.name)}_Relation_RelationTo`,\n                values: field.relationTo.reduce(\n                  (values, relation) => ({\n                    ...values,\n                    [formatName(relation)]: {\n                      value: relation,\n                    },\n                  }),\n                  {},\n                ),\n              }),\n            },\n            value: { type: GraphQLJSON },\n          },\n        }),\n      }\n    }\n\n    return {\n      type: withOperators(field, parentName),\n    }\n  },\n  richText: (field: RichTextField) => ({\n    type: withOperators(field, parentName),\n  }),\n  row: (field: RowField) =>\n    recursivelyBuildNestedPaths({\n      field,\n      nestedFieldName2: nestedFieldName,\n      parentName,\n    }),\n  select: (field: SelectField) => ({\n    type: withOperators(field, parentName),\n  }),\n  tabs: (field: TabsField) =>\n    recursivelyBuildNestedPaths({\n      field,\n      nestedFieldName2: nestedFieldName,\n      parentName,\n    }),\n  text: (field: TextField) => ({\n    type: withOperators(field, parentName),\n  }),\n  textarea: (field: TextareaField) => ({\n    type: withOperators(field, parentName),\n  }),\n  upload: (field: UploadField) => ({\n    type: withOperators(field, parentName),\n  }),\n})\n\nexport default fieldToSchemaMap\n"],"names":["fieldToSchemaMap","nestedFieldName","parentName","array","field","recursivelyBuildNestedPaths","nestedFieldName2","checkbox","type","withOperators","code","collapsible","date","email","group","json","number","point","radio","relationship","Array","isArray","relationTo","GraphQLInputObjectType","name","combineParentName","fields","GraphQLEnumType","values","reduce","relation","formatName","value","GraphQLJSON","richText","row","select","tabs","text","textarea","upload"],"mappings":"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"}

package/dist/schema/initCollections.d.ts

@@ -0,0 +1,9 @@
+import type { GraphQLInfo } from 'payload/config';
+import type { SanitizedConfig } from 'payload/types';
+type InitCollectionsGraphQLArgs = {
+    config: SanitizedConfig;
+    graphqlResult: GraphQLInfo;
+};
+declare function initCollectionsGraphQL({ config, graphqlResult }: InitCollectionsGraphQLArgs): void;
+export default initCollectionsGraphQL;
+//# sourceMappingURL=initCollections.d.ts.map

package/dist/schema/initCollections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initCollections.d.ts","sourceRoot":"","sources":["../../src/schema/initCollections.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAAgD,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BlG,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,eAAe,CAAA;IACvB,aAAa,EAAE,WAAW,CAAA;CAC3B,CAAA;AACD,iBAAS,sBAAsB,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,0BAA0B,GAAG,IAAI,CA+Z3F;AAED,eAAe,sBAAsB,CAAA"}