payload 1.15.11 → 1.15.12

package/src/graphql/schema/withOperators.ts

@@ -1,290 +0,0 @@
-import { GraphQLBoolean, GraphQLInputObjectType, GraphQLString, GraphQLList, GraphQLFloat, GraphQLEnumType, GraphQLInt } from 'graphql';
-import type { GraphQLType } from 'graphql';
-import { GraphQLJSON } from 'graphql-type-json';
-import { DateTimeResolver, EmailAddressResolver } from 'graphql-scalars';
-import { FieldAffectingData, NumberField, RadioField, SelectField, optionIsObject } from '../../fields/config/types';
-import combineParentName from '../utilities/combineParentName';
-import formatName from '../utilities/formatName';
-import operators from './operators';
-
-type staticTypes = 'number' | 'text' | 'email' | 'textarea' | 'richText' | 'json' | 'code' | 'checkbox' | 'date' | 'upload' | 'point' | 'relationship'
-
-type dynamicTypes = 'radio' | 'select'
-
-const GeoJSONObject = new GraphQLInputObjectType({
-  name: 'GeoJSONObject',
-  fields: {
-    type: { type: GraphQLString },
-    coordinates: {
-      type: GraphQLJSON,
-    },
-  },
-});
-
-type DefaultsType = {
-  [key in staticTypes]: {
-    operators: {
-      name: string;
-      type: GraphQLType | ((field: FieldAffectingData, parentName: string) => GraphQLType);
-    }[];
-  }
-} & {
-  [key in dynamicTypes]: {
-    operators: {
-      name: string;
-      type: ((field: FieldAffectingData, parentName: string) => GraphQLType);
-    }[];
-  }
-}
-
-const defaults: DefaultsType = {
-  number: {
-    operators: [
-      ...[...operators.equality, ...operators.comparison].map((operator) => ({
-        name: operator,
-        type: (field: NumberField): GraphQLType => {
-          return field?.name === 'id' ? GraphQLInt : GraphQLFloat;
-        },
-      })),
-    ],
-  },
-  text: {
-    operators: [
-      ...[...operators.equality, ...operators.partial, ...operators.contains].map((operator) => ({
-        name: operator,
-        type: GraphQLString,
-      })),
-    ],
-  },
-  email: {
-    operators: [
-      ...[...operators.equality, ...operators.partial, ...operators.contains].map((operator) => ({
-        name: operator,
-        type: EmailAddressResolver,
-      })),
-    ],
-  },
-  textarea: {
-    operators: [
-      ...[...operators.equality, ...operators.partial].map((operator) => ({
-        name: operator,
-        type: GraphQLString,
-      })),
-    ],
-  },
-  richText: {
-    operators: [
-      ...[...operators.equality, ...operators.partial].map((operator) => ({
-        name: operator,
-        type: GraphQLJSON,
-      })),
-    ],
-  },
-  json: {
-    operators: [
-      ...[...operators.equality, ...operators.partial, ...operators.geojson].map((operator) => ({
-        name: operator,
-        type: GraphQLJSON,
-      })),
-    ],
-  },
-  code: {
-    operators: [
-      ...[...operators.equality, ...operators.partial].map((operator) => ({
-        name: operator,
-        type: GraphQLString,
-      })),
-    ],
-  },
-  radio: {
-    operators: [
-      ...[...operators.equality, ...operators.partial].map((operator) => ({
-        name: operator,
-        type: (field: RadioField, parentName): GraphQLType => new GraphQLEnumType({
-          name: `${combineParentName(parentName, field.name)}_Input`,
-          values: field.options.reduce((values, option) => {
-            if (optionIsObject(option)) {
-              return {
-                ...values,
-                [formatName(option.value)]: {
-                  value: option.value,
-                },
-              };
-            }
-
-            return {
-              ...values,
-              [formatName(option)]: {
-                value: option,
-              },
-            };
-          }, {}),
-        }),
-      })),
-    ],
-  },
-  date: {
-    operators: [
-      ...[...operators.equality, ...operators.comparison, 'like'].map((operator) => ({
-        name: operator,
-        type: DateTimeResolver,
-      })),
-    ],
-  },
-  point: {
-    operators: [
-      ...[...operators.equality, ...operators.comparison, ...operators.geo].map((operator) => ({
-        name: operator,
-        type: new GraphQLList(GraphQLFloat),
-      })),
-      ...operators.geojson.map((operator) => ({
-        name: operator,
-        /**
-         * @example:
-         * within: {
-         *  type: "Polygon",
-         *  coordinates: [[
-         *   [0.0, 0.0],
-         *   [1.0, 1.0],
-         *   [1.0, 0.0],
-         *   [0.0, 0.0],
-         *  ]],
-         * }
-         * @example
-         * intersects: {
-         *  type: "Point",
-         *  coordinates: [ 0.5, 0.5 ]
-         * }
-         */
-        type: GeoJSONObject,
-      })),
-    ],
-  },
-  relationship: {
-    operators: [
-      ...[...operators.equality, ...operators.contains].map((operator) => ({
-        name: operator,
-        type: GraphQLString,
-      })),
-    ],
-  },
-  upload: {
-    operators: [
-      ...operators.equality.map((operator) => ({
-        name: operator,
-        type: GraphQLString,
-      })),
-    ],
-  },
-  checkbox: {
-    operators: [
-      ...operators.equality.map((operator) => ({
-        name: operator,
-        type: GraphQLBoolean,
-      })),
-    ],
-  },
-  select: {
-    operators: [
-      ...[...operators.equality, ...operators.contains].map((operator) => ({
-        name: operator,
-        type: (field: SelectField, parentName): GraphQLType => new GraphQLEnumType({
-          name: `${combineParentName(parentName, field.name)}_Input`,
-          values: field.options.reduce((values, option) => {
-            if (typeof option === 'object' && option.value) {
-              return {
-                ...values,
-                [formatName(option.value)]: {
-                  value: option.value,
-                },
-              };
-            }
-
-            if (typeof option === 'string') {
-              return {
-                ...values,
-                [option]: {
-                  value: option,
-                },
-              };
-            }
-
-            return values;
-          }, {}),
-        }),
-      })),
-    ],
-  },
-  // array: n/a
-  // group: n/a
-  // row: n/a
-  // collapsible: n/a
-  // tabs: n/a
-};
-
-const listOperators = ['in', 'not_in', 'all'];
-
-const gqlTypeCache: Record<string, GraphQLType> = {};
-
-/**
- * In GraphQL, you can use "where" as an argument to filter a collection. Example:
- * { Posts(where: { title: { equals: "Hello" } }) { text } }
- * This function defines the operators for a field's condition in the "where" argument of the collection (it thus gets called for every field).
- * For example, in the example above, it would control that
- * - "equals" is a valid operator for the "title" field
- * - the accepted type of the "equals" argument has to be a string.
- *
- * @param field the field for which their valid operators inside a "where" argument is being defined
- * @param parentName the name of the parent field (if any)
- * @returns all the operators (including their types) which can be used as a condition for a given field inside a where
- */
-export const withOperators = (field: FieldAffectingData, parentName: string): GraphQLInputObjectType => {
-  if (!defaults?.[field.type]) throw new Error(`Error: ${field.type} has no defaults configured.`);
-
-  const name = `${combineParentName(parentName, field.name)}_operator`;
-
-  // Get the default operators for the field type which are hard-coded above
-  const fieldOperators = [...defaults[field.type].operators];
-
-  if (!('required' in field) || !field.required) {
-    fieldOperators.push({
-      name: 'exists',
-      type: fieldOperators[0].type,
-    });
-  }
-
-
-  return new GraphQLInputObjectType({
-    name,
-    fields: fieldOperators.reduce((objectTypeFields, operator) => {
-      // Get the type of the operator. It can be either static, or dynamic (=> a function)
-      let gqlType: GraphQLType = typeof operator.type === 'function'
-        ? operator.type(field, parentName)
-        : operator.type;
-
-      // GraphQL does not allow types with duplicate names, so we use this cache to avoid that.
-      // Without this, select and radio fields would have the same name, and GraphQL would throw an error
-      // This usually only happens if a custom type is returned from the operator.type function
-      if (typeof operator.type === 'function' && 'name' in gqlType) {
-        if (gqlTypeCache[gqlType.name]) {
-          gqlType = gqlTypeCache[gqlType.name];
-        } else {
-          gqlTypeCache[gqlType.name] = gqlType;
-        }
-      }
-
-      if (listOperators.includes(operator.name)) {
-        gqlType = new GraphQLList(gqlType);
-      } else if (operator.name === 'exists') {
-        gqlType = GraphQLBoolean;
-      }
-
-      return {
-        ...objectTypeFields,
-        [operator.name]: {
-          type: gqlType,
-        },
-      };
-    }, {}),
-  });
-};

package/src/graphql/utilities/combineParentName.ts

@@ -1,5 +0,0 @@
-import formatName from './formatName';
-
-const combineParentName = (parent: string, name: string): string => formatName(`${parent ? `${parent}_` : ''}${name}`);
-
-export default combineParentName;

package/src/graphql/utilities/formatName.spec.ts

@@ -1,18 +0,0 @@
-/* eslint-disable indent */
-/* eslint-disable jest/prefer-strict-equal */
-import formatName from './formatName';
-
-describe('formatName', () => {
-  it.each`
-    char   | expected
-    ${'á'} | ${'a'}
-    ${'è'} | ${'e'}
-    ${'í'} | ${'i'}
-    ${'ó'} | ${'o'}
-    ${'ú'} | ${'u'}
-    ${'ñ'} | ${'n'}
-    ${'ü'} | ${'u'}
-  `('should convert accented character: $char', ({ char, expected }) => {
-    expect(formatName(char)).toEqual(expected);
-  });
-});

package/src/graphql/utilities/formatName.ts

@@ -1,29 +0,0 @@
-const numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-
-const formatName = (string: string): string => {
-  let sanitizedString = String(string);
-
-  const firstLetter = sanitizedString.substring(0, 1);
-
-  if (numbers.indexOf(firstLetter) > -1) {
-    sanitizedString = `_${sanitizedString}`;
-  }
-
-  const formatted = sanitizedString
-    // Convert accented characters
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '')
-
-    .replace(/\./g, '_')
-    .replace(/-|\//g, '_')
-    .replace(/\+/g, '_')
-    .replace(/,/g, '_')
-    .replace(/\(/g, '_')
-    .replace(/\)/g, '_')
-    .replace(/'/g, '_')
-    .replace(/ /g, '');
-
-  return formatted || '_';
-};
-
-export default formatName;

package/src/graphql/utilities/formatOptions.ts

@@ -1,25 +0,0 @@
-import { optionIsObject, RadioField, SelectField } from '../../fields/config/types';
-import formatName from './formatName';
-
-const formatOptions = (field: RadioField | SelectField) => {
-  return field.options.reduce((values, option) => {
-    if (optionIsObject(option)) {
-      return {
-        ...values,
-        [formatName(option.value)]: {
-          value: option.value,
-        },
-      };
-    }
-
-    return {
-      ...values,
-      [formatName(option)]: {
-        value: option,
-      },
-    };
-  }, {});
-};
-
-
-export default formatOptions;

package/src/graphql/utilities/getCheckIfLocaleObject.ts

@@ -1,2 +0,0 @@
-export default (localization: { locales: string[] }) => (value: unknown): boolean => typeof value === 'object'
-      && Object.keys(value).some((key) => localization.locales.indexOf(key) > -1);

package/src/graphql/utilities/uppercase.ts

@@ -1,11 +0,0 @@
-function uppercase(str: string): string {
-  const array1 = str.split(' ');
-  const newarray1 = [];
-
-  for (let x = 0; x < array1.length; x += 1) {
-    newarray1.push(array1[x].charAt(0).toUpperCase() + array1[x].slice(1));
-  }
-  return newarray1.join(' ');
-}
-
-export default uppercase;

package/src/index.ts

@@ -1,31 +0,0 @@
-import { Config as GeneratedTypes } from 'payload/generated-types';
-import { InitOptions } from './config/types';
-import { initHTTP } from './initHTTP';
-import { Payload as LocalPayload, BasePayload } from './payload';
-
-import type { RequestContext } from './express/types';
-
-export { getPayload } from './payload';
-
-require('isomorphic-fetch');
-
-export class Payload extends BasePayload<GeneratedTypes> {
-  async init(options: InitOptions): Promise<LocalPayload> {
-    const payload = await initHTTP(options);
-    Object.assign(this, payload);
-
-    if (!options.local) {
-      if (typeof options.onInit === 'function') await options.onInit(this);
-      if (typeof this.config.onInit === 'function') await this.config.onInit(this);
-    }
-
-    return payload;
-  }
-}
-
-const payload = new Payload();
-
-export default payload;
-module.exports = payload;
-// Export RequestContext type
-export type { RequestContext };

package/src/initHTTP.ts

@@ -1,87 +0,0 @@
-/* eslint-disable no-param-reassign */
-import express, { NextFunction, Response } from 'express';
-import { InitOptions } from './config/types';
-
-import authenticate from './express/middleware/authenticate';
-import expressMiddleware from './express/middleware';
-import initAdmin from './express/admin';
-import initAuth from './auth/init';
-import access from './auth/requestHandlers/access';
-import initCollectionsHTTP from './collections/initHTTP';
-import initPreferences from './preferences/init';
-import initGlobalsHTTP from './globals/initHTTP';
-import initGraphQLPlayground from './graphql/initPlayground';
-import initStatic from './express/static';
-import graphQLHandler from './graphql/graphQLHandler';
-import identifyAPI from './express/middleware/identifyAPI';
-import errorHandler from './express/middleware/errorHandler';
-import { PayloadRequest } from './express/types';
-import { getDataLoader } from './collections/dataloader';
-import mountEndpoints from './express/mountEndpoints';
-import { getPayload, Payload } from './payload';
-
-export const initHTTP = async (options: InitOptions): Promise<Payload> => {
-  if (typeof options.local === 'undefined') options.local = false;
-  const payload = await getPayload(options);
-
-  if (!options.local) {
-    payload.router = express.Router();
-    payload.router.use(...expressMiddleware(payload));
-    initAuth(payload);
-
-    initCollectionsHTTP(payload);
-    initGlobalsHTTP(payload);
-
-    options.express.use((req: PayloadRequest, res, next) => {
-      req.payload = payload;
-      next();
-    });
-
-    options.express.use((req: PayloadRequest, res: Response, next: NextFunction): void => {
-      req.payloadDataLoader = getDataLoader(req);
-      return next();
-    });
-
-    payload.express = options.express;
-
-    if (payload.config.rateLimit.trustProxy) {
-      payload.express.set('trust proxy', 1);
-    }
-
-    await initAdmin(payload);
-    initPreferences(payload);
-
-    payload.router.get('/access', access);
-
-    if (!payload.config.graphQL.disable) {
-      payload.router.use(
-        payload.config.routes.graphQL,
-        (req, res, next): void => {
-          if (req.method === 'OPTIONS') {
-            res.sendStatus(204);
-          } else {
-            next();
-          }
-        },
-        identifyAPI('GraphQL'),
-        (req: PayloadRequest, res: Response, next) => graphQLHandler(req, res)(req, res, next),
-      );
-      initGraphQLPlayground(payload);
-    }
-
-    mountEndpoints(options.express, payload.router, payload.config.endpoints);
-
-    // Bind router to API
-    payload.express.use(payload.config.routes.api, payload.router);
-
-    // Enable static routes for all collections permitting upload
-    initStatic(payload);
-
-    payload.errorHandler = errorHandler(payload.config, payload.logger);
-    payload.router.use(payload.errorHandler);
-
-    payload.authenticate = authenticate(payload.config);
-  }
-
-  return payload;
-};

package/src/localization/middleware.ts

@@ -1,37 +0,0 @@
-/**
- * sets request locale
- *
- * @param localization
- * @returns {Function}
- */
-export default function localizationMiddleware(localization) {
-  const middleware = (req, res, next) => {
-    if (localization) {
-      const validLocales = [...localization.locales, 'all'];
-      const validFallbackLocales = [...localization.locales, 'null'];
-
-      let requestedLocale = req.query.locale || localization.defaultLocale;
-      let requestedFallbackLocale = req.query['fallback-locale'] || localization.defaultLocale;
-
-      if (req.body) {
-        if (req.body.locale) requestedLocale = req.body.locale;
-        if (req.body['fallback-locale']) requestedFallbackLocale = req.body['fallback-locale'];
-      }
-
-      if (requestedFallbackLocale === 'none') requestedFallbackLocale = 'null';
-      if (requestedLocale === '*' || requestedLocale === 'all') requestedLocale = 'all';
-
-      if (validLocales.find((locale) => locale === requestedLocale)) {
-        req.locale = requestedLocale;
-      }
-
-      if (validFallbackLocales.find((locale) => locale === requestedFallbackLocale)) {
-        req.fallbackLocale = requestedFallbackLocale;
-      }
-    }
-
-    return next();
-  };
-
-  return middleware;
-}

package/src/localization/sanitizeFallbackLocale.ts

@@ -1,9 +0,0 @@
-const sanitizeFallbackLocale = (fallbackLocale) => {
-  if (fallbackLocale === 'null' || fallbackLocale === 'none' || fallbackLocale === 'false' || fallbackLocale === false || fallbackLocale === null) {
-    return null;
-  }
-
-  return fallbackLocale;
-};
-
-export default sanitizeFallbackLocale;