@strapi/plugin-graphql 4.15.5-alpha.6 → 4.16.0

package/admin/src/translations/tr.json

@@ -1,5 +0,0 @@
-{
-  "plugin.description.long": "Varsayılan API metodları ile bir GraphQL uç noktası ekler.",
-  "plugin.description.short": "Varsayılan API metodları ile bir GraphQL uç noktası ekler.",
-  "plugin.name": "GraphQL"
-}

package/admin/src/translations/zh-Hans.json

@@ -1,5 +0,0 @@
-{
-  "plugin.description.long": "为默认API方法添加GraphQL端点",
-  "plugin.description.short": "为默认API方法添加GraphQL端点",
-  "plugin.name": "GraphQL"
-}

package/admin/src/translations/zh.json

@@ -1,5 +0,0 @@
-{
-  "plugin.description.long": "新增使用預設 API 方法的 GraphQL 端點。",
-  "plugin.description.short": "新增使用預設 API 方法的 GraphQL 端點。",
-  "plugin.name": "GraphQL"
-}

package/packup.config.ts

@@ -1,42 +0,0 @@
-import { Config, defineConfig } from '@strapi/pack-up';
-import { transformWithEsbuild } from 'vite';
-
-const config: Config = defineConfig({
-  bundles: [
-    {
-      source: './admin/src/index.js',
-      import: './dist/admin/index.mjs',
-      require: './dist/admin/index.js',
-      runtime: 'web',
-    },
-  ],
-  dist: './dist',
-  /**
-   * Because we're exporting a server & client package
-   * which have different runtimes we want to ignore
-   * what they look like in the package.json
-   */
-  exports: {},
-  plugins: [
-    {
-      name: 'treat-js-files-as-jsx',
-      async transform(code, id) {
-        /**
-         * Matches all files in src/ and ee/ that end with .js
-         */
-        if (!id.match(/src\/.*\.js$/) && !id.match(/ee\/.*\.js$/)) {
-          return null;
-        }
-
-        // Use the exposed transform from vite, instead of directly
-        // transforming with esbuild
-        return transformWithEsbuild(code, id, {
-          loader: 'tsx',
-          jsx: 'automatic',
-        });
-      },
-    },
-  ],
-});
-
-export default config;

package/server/bootstrap.js

@@ -1,134 +0,0 @@
-'use strict';
-
-const { isEmpty, mergeWith, isArray } = require('lodash/fp');
-const { ApolloServer } = require('apollo-server-koa');
-const {
-  ApolloServerPluginLandingPageDisabled,
-  ApolloServerPluginLandingPageGraphQLPlayground,
-} = require('apollo-server-core');
-const depthLimit = require('graphql-depth-limit');
-const { graphqlUploadKoa } = require('graphql-upload');
-const formatGraphqlError = require('./format-graphql-error');
-
-const merge = mergeWith((a, b) => {
-  if (isArray(a) && isArray(b)) {
-    return a.concat(b);
-  }
-});
-
-/**
- * Register the upload middleware powered by graphql-upload in Strapi
- * @param {object} strapi
- * @param {string} path
- */
-const useUploadMiddleware = (strapi, path) => {
-  const uploadMiddleware = graphqlUploadKoa();
-
-  strapi.server.app.use((ctx, next) => {
-    if (ctx.path === path) {
-      return uploadMiddleware(ctx, next);
-    }
-
-    return next();
-  });
-};
-
-module.exports = async ({ strapi }) => {
-  // Generate the GraphQL schema for the content API
-  const schema = strapi.plugin('graphql').service('content-api').buildSchema();
-
-  if (isEmpty(schema)) {
-    strapi.log.warn('The GraphQL schema has not been generated because it is empty');
-
-    return;
-  }
-
-  const { config } = strapi.plugin('graphql');
-
-  const path = config('endpoint');
-
-  const defaultServerConfig = {
-    // Schema
-    schema,
-
-    // Initialize loaders for this request.
-    context: ({ ctx }) => ({
-      state: ctx.state,
-      koaContext: ctx,
-    }),
-
-    // Validation
-    validationRules: [depthLimit(config('depthLimit'))],
-
-    // Errors
-    formatError: formatGraphqlError,
-
-    // Misc
-    cors: false,
-    uploads: false,
-    bodyParserConfig: true,
-
-    plugins: [
-      process.env.NODE_ENV === 'production' && !config('playgroundAlways')
-        ? ApolloServerPluginLandingPageDisabled()
-        : ApolloServerPluginLandingPageGraphQLPlayground(),
-    ],
-
-    cache: 'bounded',
-  };
-
-  const serverConfig = merge(defaultServerConfig, config('apolloServer'));
-
-  // Create a new Apollo server
-  const server = new ApolloServer(serverConfig);
-
-  // Register the upload middleware
-  useUploadMiddleware(strapi, path);
-
-  try {
-    // Since Apollo-Server v3, server.start() must be called before using server.applyMiddleware()
-    await server.start();
-  } catch (e) {
-    strapi.log.error('Failed to start the Apollo server', e.message);
-  }
-
-  // Link the Apollo server & the Strapi app
-  strapi.server.routes([
-    {
-      method: 'ALL',
-      path,
-      handler: [
-        (ctx, next) => {
-          ctx.state.route = {
-            info: {
-              // Indicate it's a content API route
-              type: 'content-api',
-            },
-          };
-
-          // allow graphql playground to load without authentication
-          if (ctx.request.method === 'GET') return next();
-
-          return strapi.auth.authenticate(ctx, next);
-        },
-
-        // Apollo Server
-        server.getMiddleware({
-          path,
-          cors: serverConfig.cors,
-          bodyParserConfig: serverConfig.bodyParserConfig,
-        }),
-      ],
-      config: {
-        auth: false,
-      },
-    },
-  ]);
-
-  // Register destroy behavior
-  // We're doing it here instead of exposing a destroy method to the strapi-server.js
-  // file since we need to have access to the ApolloServer instance
-  strapi.plugin('graphql').destroy = async () => {
-    await server.stop();
-  };
-};

package/server/config/default-config.js

@@ -1,13 +0,0 @@
-'use strict';
-
-module.exports = {
-  shadowCRUD: true,
-
-  endpoint: '/graphql',
-
-  subscriptions: false,
-
-  maxLimit: -1,
-
-  apolloServer: {},
-};

package/server/config/index.js

@@ -1,7 +0,0 @@
-'use strict';
-
-const defaultConfig = require('./default-config');
-
-module.exports = {
-  default: defaultConfig,
-};

package/server/format-graphql-error.js

@@ -1,45 +0,0 @@
-'use strict';
-
-const { toUpper, snakeCase, pick, isEmpty } = require('lodash/fp');
-const { HttpError, ForbiddenError, UnauthorizedError, ApplicationError, ValidationError } =
-  require('@strapi/utils').errors;
-const {
-  ApolloError,
-  UserInputError: ApolloUserInputError,
-  ForbiddenError: ApolloForbiddenError,
-} = require('apollo-server-koa');
-const { GraphQLError } = require('graphql');
-
-const formatToCode = (name) => `STRAPI_${toUpper(snakeCase(name))}`;
-const formatErrorToExtension = (error) => ({ error: pick(['name', 'message', 'details'])(error) });
-
-const formatGraphqlError = (error) => {
-  const { originalError } = error;
-
-  if (isEmpty(originalError)) {
-    return error;
-  }
-
-  if (originalError instanceof ForbiddenError || originalError instanceof UnauthorizedError) {
-    return new ApolloForbiddenError(originalError.message, formatErrorToExtension(originalError));
-  }
-
-  if (originalError instanceof ValidationError) {
-    return new ApolloUserInputError(originalError.message, formatErrorToExtension(originalError));
-  }
-
-  if (originalError instanceof ApplicationError || originalError instanceof HttpError) {
-    const name = formatToCode(originalError.name);
-    return new ApolloError(originalError.message, name, formatErrorToExtension(originalError));
-  }
-
-  if (originalError instanceof ApolloError || originalError instanceof GraphQLError) {
-    return error;
-  }
-
-  // Internal server error
-  strapi.log.error(originalError);
-  return new ApolloError('Internal Server Error', 'INTERNAL_SERVER_ERROR');
-};
-
-module.exports = formatGraphqlError;

package/server/services/builders/dynamic-zones.js

@@ -1,97 +0,0 @@
-'use strict';
-
-const { Kind, valueFromASTUntyped } = require('graphql');
-const { omit } = require('lodash/fp');
-const { unionType, scalarType } = require('nexus');
-const { ApplicationError } = require('@strapi/utils').errors;
-
-module.exports = ({ strapi }) => {
-  const buildTypeDefinition = (name, components) => {
-    const { ERROR_TYPE_NAME } = strapi.plugin('graphql').service('constants');
-    const isEmpty = components.length === 0;
-
-    const componentsTypeNames = components.map((componentUID) => {
-      const component = strapi.components[componentUID];
-
-      if (!component) {
-        throw new ApplicationError(
-          `Trying to create a dynamic zone type with an unknown component: "${componentUID}"`
-        );
-      }
-
-      return component.globalId;
-    });
-
-    return unionType({
-      name,
-
-      resolveType(obj) {
-        if (isEmpty) {
-          return ERROR_TYPE_NAME;
-        }
-
-        return strapi.components[obj.__component].globalId;
-      },
-
-      definition(t) {
-        t.members(...componentsTypeNames, ERROR_TYPE_NAME);
-      },
-    });
-  };
-
-  const buildInputDefinition = (name, components) => {
-    const parseData = (value) => {
-      const component = Object.values(strapi.components).find(
-        (component) => component.globalId === value.__typename
-      );
-
-      if (!component) {
-        throw new ApplicationError(
-          `Component not found. expected one of: ${components
-            .map((uid) => strapi.components[uid].globalId)
-            .join(', ')}`
-        );
-      }
-
-      return {
-        __component: component.uid,
-        ...omit(['__typename'], value),
-      };
-    };
-
-    return scalarType({
-      name,
-
-      serialize: (value) => value,
-
-      parseValue: (value) => parseData(value),
-
-      parseLiteral(ast, variables) {
-        if (ast.kind !== Kind.OBJECT) {
-          return undefined;
-        }
-
-        const value = valueFromASTUntyped(ast, variables);
-        return parseData(value);
-      },
-    });
-  };
-
-  return {
-    /**
-     * Build a Nexus dynamic zone type from a Strapi dz attribute
-     * @param {object} definition - The definition of the dynamic zone
-     * @param {string} name - the name of the dynamic zone
-     * @param {string} inputName - the name of the dynamic zone's input
-     * @return {[NexusUnionTypeDef, NexusScalarTypeDef]}
-     */
-    buildDynamicZoneDefinition(definition, name, inputName) {
-      const { components } = definition;
-
-      const typeDefinition = buildTypeDefinition(name, components);
-      const inputDefinition = buildInputDefinition(inputName, components);
-
-      return [typeDefinition, inputDefinition];
-    },
-  };
-};

package/server/services/builders/entity-meta.js

@@ -1,7 +0,0 @@
-'use strict';
-
-function buildEntityMetaDefinition(/* contentType */) {}
-
-module.exports = () => ({
-  buildEntityMetaDefinition,
-});

package/server/services/builders/entity.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const { objectType } = require('nexus');
-const { prop, identity, isEmpty } = require('lodash/fp');
-
-module.exports = ({ strapi }) => {
-  const { naming } = strapi.plugin('graphql').service('utils');
-
-  return {
-    /**
-     * Build a higher level type for a content type which contains the attributes, the ID and the metadata
-     * @param {object} contentType The content type which will be used to build its entity type
-     * @return {NexusObjectTypeDef}
-     */
-    buildEntityDefinition(contentType) {
-      const { attributes } = contentType;
-
-      const name = naming.getEntityName(contentType);
-      const typeName = naming.getTypeName(contentType);
-
-      return objectType({
-        name,
-
-        definition(t) {
-          // Keep the ID attribute at the top level
-          t.id('id', { resolve: prop('id') });
-
-          if (!isEmpty(attributes)) {
-            // Keep the fetched object into a dedicated `attributes` field
-            // TODO: [v4] precise why we keep the ID
-            t.field('attributes', {
-              type: typeName,
-              resolve: identity,
-            });
-          }
-
-          // todo[v4]: add the meta field to the entity when there will be data in it (can't add an empty type for now)
-          // t.field('meta', { type: utils.getEntityMetaName(contentType) });
-        },
-      });
-    },
-  };
-};

package/server/services/builders/enums.js

@@ -1,26 +0,0 @@
-'use strict';
-
-const { enumType } = require('nexus');
-const { set } = require('lodash/fp');
-const { toRegressedEnumValue } = require('@strapi/utils');
-
-/**
- * Build a Nexus enum type from a Strapi enum attribute
- * @param {object} definition - The definition of the enum
- * @param {string[]} definition.enum - The params of the enum
- * @param {string} name - The name of the enum
- * @return {NexusEnumTypeDef}
- */
-const buildEnumTypeDefinition = (definition, name) => {
-  return enumType({
-    name,
-    members: definition.enum.reduce(
-      (acc, value) => set(toRegressedEnumValue(value), value, acc),
-      {}
-    ),
-  });
-};
-
-module.exports = () => ({
-  buildEnumTypeDefinition,
-});

package/server/services/builders/filters/content-type.js

@@ -1,111 +0,0 @@
-'use strict';
-
-const { inputObjectType } = require('nexus');
-
-module.exports = ({ strapi }) => {
-  const rootLevelOperators = () => {
-    const { operators } = strapi.plugin('graphql').service('builders').filters;
-
-    return [operators.and, operators.or, operators.not];
-  };
-
-  const addScalarAttribute = (builder, attributeName, attribute) => {
-    const { naming, mappers } = strapi.plugin('graphql').service('utils');
-
-    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
-
-    builder.field(attributeName, { type: naming.getScalarFilterInputTypeName(gqlType) });
-  };
-
-  const addRelationalAttribute = (builder, attributeName, attribute) => {
-    const utils = strapi.plugin('graphql').service('utils');
-    const extension = strapi.plugin('graphql').service('extension');
-    const { getFiltersInputTypeName } = utils.naming;
-    const { isMorphRelation } = utils.attributes;
-
-    const model = strapi.getModel(attribute.target);
-
-    // If there is no model corresponding to the attribute configuration
-    // or if the attribute is a polymorphic relation, then ignore it
-    if (!model || isMorphRelation(attribute)) return;
-
-    // If the target model is disabled, then ignore it too
-    if (extension.shadowCRUD(model.uid).isDisabled()) return;
-
-    builder.field(attributeName, { type: getFiltersInputTypeName(model) });
-  };
-
-  const addComponentAttribute = (builder, attributeName, attribute) => {
-    const utils = strapi.plugin('graphql').service('utils');
-    const extension = strapi.plugin('graphql').service('extension');
-    const { getFiltersInputTypeName } = utils.naming;
-
-    const component = strapi.getModel(attribute.component);
-
-    // If there is no component corresponding to the attribute configuration, then ignore it
-    if (!component) return;
-
-    // If the component is disabled, then ignore it too
-    if (extension.shadowCRUD(component.uid).isDisabled()) return;
-
-    builder.field(attributeName, { type: getFiltersInputTypeName(component) });
-  };
-
-  const buildContentTypeFilters = (contentType) => {
-    const utils = strapi.plugin('graphql').service('utils');
-    const extension = strapi.plugin('graphql').service('extension');
-
-    const { getFiltersInputTypeName, getScalarFilterInputTypeName } = utils.naming;
-    const { isStrapiScalar, isRelation, isComponent } = utils.attributes;
-
-    const { attributes } = contentType;
-
-    const filtersTypeName = getFiltersInputTypeName(contentType);
-
-    return inputObjectType({
-      name: filtersTypeName,
-
-      definition(t) {
-        const validAttributes = Object.entries(attributes).filter(([attributeName]) =>
-          extension.shadowCRUD(contentType.uid).field(attributeName).hasFiltersEnabeld()
-        );
-
-        const isIDFilterEnabled = extension
-          .shadowCRUD(contentType.uid)
-          .field('id')
-          .hasFiltersEnabeld();
-        // Add an ID filter to the collection types
-        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
-          t.field('id', { type: getScalarFilterInputTypeName('ID') });
-        }
-
-        // Add every defined attribute
-        for (const [attributeName, attribute] of validAttributes) {
-          // Handle scalars
-          if (isStrapiScalar(attribute)) {
-            addScalarAttribute(t, attributeName, attribute);
-          }
-
-          // Handle relations
-          else if (isRelation(attribute)) {
-            addRelationalAttribute(t, attributeName, attribute);
-          }
-
-          // Handle components
-          else if (isComponent(attribute)) {
-            addComponentAttribute(t, attributeName, attribute);
-          }
-        }
-
-        // Conditional clauses
-        for (const operator of rootLevelOperators()) {
-          operator.add(t, filtersTypeName);
-        }
-      },
-    });
-  };
-
-  return {
-    buildContentTypeFilters,
-  };
-};

package/server/services/builders/filters/index.js

@@ -1,7 +0,0 @@
-'use strict';
-
-const contentType = require('./content-type');
-
-module.exports = (context) => ({
-  ...contentType(context),
-});

package/server/services/builders/filters/operators/and.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const { list } = require('nexus');
-
-const AND_FIELD_NAME = 'and';
-
-module.exports = () => ({
-  fieldName: AND_FIELD_NAME,
-
-  strapiOperator: '$and',
-
-  add(t, type) {
-    t.field(AND_FIELD_NAME, { type: list(type) });
-  },
-});

package/server/services/builders/filters/operators/between.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const { list } = require('nexus');
-
-const BETWEEN_FIELD_NAME = 'between';
-
-module.exports = () => ({
-  fieldName: BETWEEN_FIELD_NAME,
-
-  strapiOperator: '$between',
-
-  add(t, type) {
-    t.field(BETWEEN_FIELD_NAME, { type: list(type) });
-  },
-});

package/server/services/builders/filters/operators/contains.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const CONTAINS_FIELD_NAME = 'contains';
-
-module.exports = () => ({
-  fieldName: CONTAINS_FIELD_NAME,
-
-  strapiOperator: '$contains',
-
-  add(t, type) {
-    t.field(CONTAINS_FIELD_NAME, { type });
-  },
-});

package/server/services/builders/filters/operators/containsi.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const CONTAINSI_FIELD_NAME = 'containsi';
-
-module.exports = () => ({
-  fieldName: CONTAINSI_FIELD_NAME,
-
-  strapiOperator: '$containsi',
-
-  add(t, type) {
-    t.field(CONTAINSI_FIELD_NAME, { type });
-  },
-});

package/server/services/builders/filters/operators/ends-with.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const ENDS_WITH_FIELD_NAME = 'endsWith';
-
-module.exports = () => ({
-  fieldName: ENDS_WITH_FIELD_NAME,
-
-  strapiOperator: '$endsWith',
-
-  add(t, type) {
-    t.field(ENDS_WITH_FIELD_NAME, { type });
-  },
-});

package/server/services/builders/filters/operators/eq.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const { ValidationError } = require('@strapi/utils').errors;
-
-const EQ_FIELD_NAME = 'eq';
-
-module.exports = ({ strapi }) => ({
-  fieldName: EQ_FIELD_NAME,
-
-  strapiOperator: '$eq',
-
-  add(t, type) {
-    const { GRAPHQL_SCALARS } = strapi.plugin('graphql').service('constants');
-
-    if (!GRAPHQL_SCALARS.includes(type)) {
-      throw new ValidationError(
-        `Can't use "${EQ_FIELD_NAME}" operator. "${type}" is not a valid scalar`
-      );
-    }
-
-    t.field(EQ_FIELD_NAME, { type });
-  },
-});

package/server/services/builders/filters/operators/eqi.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const EQI_FIELD_NAME = 'eqi';
-
-module.exports = () => ({
-  fieldName: EQI_FIELD_NAME,
-
-  strapiOperator: '$eqi',
-
-  add(t, type) {
-    t.field(EQI_FIELD_NAME, { type });
-  },
-});