@webiny/api-headless-cms 5.23.1 → 5.24.0-beta.0

package/content/graphQLHandlerFactory.js

@@ -68,6 +68,11 @@ const generateSchema = async args => {
     context
   } = args;
   context.plugins.register(await (0, _buildSchemaPlugins.default)(context));
+  /**
+   * Really hard to type this to satisfy the makeExecutableSchema
+   */
+  // TODO @ts-refactor
+
   const typeDefs = [];
   const resolvers = []; // Get schema definitions from plugins
 
@@ -133,7 +138,7 @@ const checkEndpointAccess = async context => {
 
 const graphQLHandlerFactory = (options = {}) => {
   const debug = (0, _boolean.boolean)(options.debug);
-  return [...(debug ? (0, _debugPlugins.default)() : []), {
+  const handler = {
     type: "handler",
     name: "handler-graphql-content-model",
 
@@ -173,7 +178,8 @@ const graphQLHandlerFactory = (options = {}) => {
       return respond(http, result);
     }
 
-  }];
+  };
+  return [...(debug ? (0, _debugPlugins.default)() : []), handler];
 };
 
 exports.graphQLHandlerFactory = graphQLHandlerFactory;

package/content/plugins/crud/contentEntry/afterDelete.d.ts

@@ -1,7 +1,8 @@
 import { Topic } from "@webiny/pubsub/types";
 import { AfterEntryDeleteTopicParams, CmsContext } from "../../../../types";
-export interface Params {
+interface AssignAfterEntryDeleteParams {
     context: CmsContext;
     onAfterEntryDelete: Topic<AfterEntryDeleteTopicParams>;
 }
-export declare const assignAfterEntryDelete: (params: Params) => void;
+export declare const assignAfterEntryDelete: (params: AssignAfterEntryDeleteParams) => void;
+export {};

package/content/plugins/crud/contentEntry/beforeCreate.d.ts

@@ -1,7 +1,8 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeEntryCreateTopicParams, CmsContext } from "../../../../types";
-export interface Params {
+interface AssignBeforeEntryCreateParams {
     context: CmsContext;
     onBeforeEntryCreate: Topic<BeforeEntryCreateTopicParams>;
 }
-export declare const assignBeforeEntryCreate: (params: Params) => void;
+export declare const assignBeforeEntryCreate: (params: AssignBeforeEntryCreateParams) => void;
+export {};

package/content/plugins/crud/contentEntry/beforeUpdate.d.ts

@@ -1,7 +1,8 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeEntryUpdateTopicParams, CmsContext } from "../../../../types";
-export interface Params {
+interface AssignBeforeEntryUpdateParams {
     context: CmsContext;
     onBeforeEntryUpdate: Topic<BeforeEntryUpdateTopicParams>;
 }
-export declare const assignBeforeEntryUpdate: (params: Params) => void;
+export declare const assignBeforeEntryUpdate: (params: AssignBeforeEntryUpdateParams) => void;
+export {};

package/content/plugins/crud/contentEntry/markLockedFields.d.ts

@@ -1,5 +1,5 @@
 import { CmsEntry, CmsModel, CmsContext } from "../../../../types";
-export interface MarkLockedFieldsParams {
+interface MarkLockedFieldsParams {
     model: CmsModel;
     entry: CmsEntry;
     context: CmsContext;
@@ -10,3 +10,4 @@ export interface MarkFieldsUnlockedParams {
     model: CmsModel;
 }
 export declare const markUnlockedFields: (params: MarkFieldsUnlockedParams) => Promise<void>;
+export {};

package/content/plugins/crud/contentModel/afterCreate.d.ts

@@ -1,7 +1,8 @@
 import { AfterModelCreateTopicParams, CmsContext } from "../../../../types";
 import { Topic } from "@webiny/pubsub/types";
-export interface Params {
+interface AssignAfterModelCreateParams {
     onAfterModelCreate: Topic<AfterModelCreateTopicParams>;
     context: CmsContext;
 }
-export declare const assignAfterModelCreate: (params: Params) => void;
+export declare const assignAfterModelCreate: (params: AssignAfterModelCreateParams) => void;
+export {};

package/content/plugins/crud/contentModel/afterDelete.d.ts

@@ -1,7 +1,8 @@
 import { AfterModelDeleteTopicParams, CmsContext } from "../../../../types";
 import { Topic } from "@webiny/pubsub/types";
-export interface Params {
+interface AssignAfterModelDeleteParams {
     onAfterModelDelete: Topic<AfterModelDeleteTopicParams>;
     context: CmsContext;
 }
-export declare const assignAfterModelDelete: (params: Params) => void;
+export declare const assignAfterModelDelete: (params: AssignAfterModelDeleteParams) => void;
+export {};

package/content/plugins/crud/contentModel/afterUpdate.d.ts

@@ -1,7 +1,8 @@
 import { AfterModelUpdateTopicParams, CmsContext } from "../../../../types";
 import { Topic } from "@webiny/pubsub/types";
-export interface Params {
+interface AssignAfterModelUpdateParams {
     onAfterModelUpdate: Topic<AfterModelUpdateTopicParams>;
     context: CmsContext;
 }
-export declare const assignAfterModelUpdate: (params: Params) => void;
+export declare const assignAfterModelUpdate: (params: AssignAfterModelUpdateParams) => void;
+export {};

package/content/plugins/crud/contentModel/beforeCreate.d.ts

@@ -1,7 +1,7 @@
 import { BeforeModelCreateTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
 import { Topic } from "@webiny/pubsub/types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeModelCreateParams {
     onBeforeModelCreate: Topic<BeforeModelCreateTopicParams>;
     onBeforeModelCreateFrom: Topic<BeforeModelCreateTopicParams>;
     storageOperations: HeadlessCmsStorageOperations;
@@ -11,4 +11,5 @@ export interface Params {
  * We attach both on before create and createFrom events here.
  * Callables are identical.
  */
-export declare const assignBeforeModelCreate: (params: Params) => void;
+export declare const assignBeforeModelCreate: (params: AssignBeforeModelCreateParams) => void;
+export {};

package/content/plugins/crud/contentModel/beforeDelete.d.ts

@@ -1,9 +1,10 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeModelDeleteTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeModelDeleteParams {
     onBeforeModelDelete: Topic<BeforeModelDeleteTopicParams>;
     storageOperations: HeadlessCmsStorageOperations;
     plugins: PluginsContainer;
 }
-export declare const assignBeforeModelDelete: (params: Params) => void;
+export declare const assignBeforeModelDelete: (params: AssignBeforeModelDeleteParams) => void;
+export {};

package/content/plugins/crud/contentModel/beforeUpdate.d.ts

@@ -1,9 +1,10 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeModelUpdateTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeModelUpdateParams {
     onBeforeModelUpdate: Topic<BeforeModelUpdateTopicParams>;
     storageOperations: HeadlessCmsStorageOperations;
     plugins: PluginsContainer;
 }
-export declare const assignBeforeModelUpdate: (params: Params) => void;
+export declare const assignBeforeModelUpdate: (params: AssignBeforeModelUpdateParams) => void;
+export {};

package/content/plugins/crud/contentModel/beforeUpdate.js

@@ -7,10 +7,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.assignBeforeModelUpdate = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
 var _error = _interopRequireDefault(require("@webiny/error"));
 
 var _CmsModelPlugin = require("../../CmsModelPlugin");
 
+var _createManageSDL = require("../../schema/createManageSDL");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
 const defaultTitleFieldId = "id";
 const allowedTitleFieldTypes = ["text", "number"];
 
@@ -53,6 +63,49 @@ const getContentModelTitleFieldId = (fields, titleFieldId) => {
   return target.fieldId;
 };
 
+const extractInvalidField = (model, err) => {
+  const sdl = err.source.body; // Find the invalid type
+
+  const {
+    line: lineNumber
+  } = err.locations[0];
+  const sdlLines = sdl.split("\n");
+  let sdlLine;
+  let gqlType;
+
+  for (let i = lineNumber; i > 0; i--) {
+    if (sdlLine && sdlLine.includes("type ")) {
+      gqlType = sdlLine.match(/type\s+(.*?)\s+{/);
+      break;
+    }
+
+    sdlLine = sdlLines[i];
+  }
+
+  let invalidField;
+
+  if (Array.isArray(gqlType)) {
+    const fieldRegex = new RegExp(`([^\\s+].*?):\\s+\\[?${gqlType[1]}!?\\]?`);
+    invalidField = sdl.match(fieldRegex)[1];
+  }
+
+  let message = `See more details in the browser console.`;
+
+  if (invalidField) {
+    message = `Please review the definition of "${invalidField}" field.`;
+  }
+
+  return {
+    data: {
+      modelId: model.modelId,
+      sdl,
+      invalidField
+    },
+    code: "INVALID_MODEL_DEFINITION",
+    message: [`Model "${model.modelId}" was not saved!`, message].join("\n")
+  };
+};
+
 const assignBeforeModelUpdate = params => {
   const {
     onBeforeModelUpdate,
@@ -90,6 +143,22 @@ const assignBeforeModelUpdate = params => {
       }
     }
 
+    if (fields.length) {
+      // Make sure that this model can be safely converted to a GraphQL SDL
+      const schema = (0, _createManageSDL.createManageSDL)({
+        model,
+        fieldTypePlugins: fieldTypePlugins.reduce((acc, pl) => _objectSpread(_objectSpread({}, acc), {}, {
+          [pl.fieldType]: pl
+        }), {})
+      });
+
+      try {
+        (0, _graphqlTag.default)(schema);
+      } catch (err) {
+        throw new _error.default(extractInvalidField(model, err));
+      }
+    }
+
     model.titleFieldId = getContentModelTitleFieldId(fields, titleFieldId);
     const cmsLockedFieldPlugins = plugins.byType("cms-model-locked-field"); // We must not allow removal or changes in fields that are already in use in content entries.
 

package/content/plugins/crud/contentModel/contentModelManagerFactory.d.ts

@@ -1,2 +1,2 @@
-import { CmsModel, CmsContext } from "../../../../types";
-export declare const contentModelManagerFactory: (context: CmsContext, model: CmsModel) => Promise<import("../../../../types").CmsModelManager>;
+import { CmsModel, CmsContext, CmsModelManager } from "../../../../types";
+export declare const contentModelManagerFactory: (context: CmsContext, model: CmsModel) => Promise<CmsModelManager>;

package/content/plugins/crud/contentModel/models.js

@@ -17,6 +17,15 @@ var _fields = require("@commodo/fields");
 
 var _idValidation = _interopRequireDefault(require("./idValidation"));
 
+/**
+ * Package commodo-fields-object does not have types
+ */
+// @ts-ignore
+
+/**
+ * Package commodo-fields does not have object.
+ */
+// @ts-ignore
 const requiredShortString = _validation.validation.create("required,maxLength:255");
 
 const shortString = _validation.validation.create("maxLength:255");

package/content/plugins/crud/contentModelGroup/beforeCreate.d.ts

@@ -1,9 +1,10 @@
 import { BeforeGroupCreateTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
 import { Topic } from "@webiny/pubsub/types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeGroupCreateParams {
     onBeforeCreate: Topic<BeforeGroupCreateTopicParams>;
     plugins: PluginsContainer;
     storageOperations: HeadlessCmsStorageOperations;
 }
-export declare const assignBeforeGroupCreate: (params: Params) => void;
+export declare const assignBeforeGroupCreate: (params: AssignBeforeGroupCreateParams) => void;
+export {};

package/content/plugins/crud/contentModelGroup/beforeDelete.d.ts

@@ -1,9 +1,10 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeGroupDeleteTopicParams, HeadlessCmsStorageOperations } from "../../../../types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeGroupDeleteParams {
     onBeforeDelete: Topic<BeforeGroupDeleteTopicParams>;
     plugins: PluginsContainer;
     storageOperations: HeadlessCmsStorageOperations;
 }
-export declare const assignBeforeGroupDelete: (params: Params) => void;
+export declare const assignBeforeGroupDelete: (params: AssignBeforeGroupDeleteParams) => void;
+export {};

package/content/plugins/crud/contentModelGroup/beforeUpdate.d.ts

@@ -1,8 +1,9 @@
 import { Topic } from "@webiny/pubsub/types";
 import { BeforeGroupUpdateTopicParams } from "../../../../types";
 import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
+interface AssignBeforeGroupUpdateParams {
     onBeforeUpdate: Topic<BeforeGroupUpdateTopicParams>;
     plugins: PluginsContainer;
 }
-export declare const assignBeforeGroupUpdate: (params: Params) => void;
+export declare const assignBeforeGroupUpdate: (params: AssignBeforeGroupUpdateParams) => void;
+export {};

package/content/plugins/graphqlFields/datetime.js

@@ -15,7 +15,9 @@ const fieldGraphQLTypes = {
 };
 
 const getFieldGraphQLType = field => {
-  const type = field.settings.type;
+  var _field$settings;
+
+  const type = (_field$settings = field.settings) === null || _field$settings === void 0 ? void 0 : _field$settings.type;
 
   if (!type || !fieldGraphQLTypes[type]) {
     return "DateTime";

package/content/plugins/graphqlFields/object.js

@@ -17,23 +17,19 @@ var _createTypeName = require("../utils/createTypeName");
 
 var _requiredField = require("./requiredField");
 
-const typeFromField = ({
-  typeOfType,
-  model,
-  type,
-  field,
-  fieldTypePlugins
-}) => {
+const typeFromField = params => {
+  const {
+    typeOfType,
+    model,
+    type,
+    field,
+    fieldTypePlugins
+  } = params;
   const typeSuffix = typeOfType === "input" ? "Input" : "";
   const typeName = (0, _createTypeName.createTypeName)(model.modelId);
   const mTypeName = (0, _createTypeName.createManageTypeName)(typeName); // `field` is an "object" field
 
-  const fields = field.settings.fields;
-
-  if (!fields || fields.length === 0) {
-    return null;
-  }
-
+  const fields = field.settings.fields || [];
   const fieldTypeName = `${mTypeName}_${(0, _upperFirst.default)(field.fieldId)}`;
   const typeFields = [];
   const nestedTypes = []; // Once the loop below starts, we'll be executing a recursive "object" type generation.

package/content/plugins/graphqlFields/ref.js

@@ -53,6 +53,19 @@ const appendTypename = (entries, typename) => {
     });
   });
 };
+/**
+ * We cast settings.models as object to have modelId because internally we know that it is so.
+ * Internal stuff so we are sure that settings.models contains what we require.
+ */
+
+
+const getFieldModels = field => {
+  if (!field.settings || Array.isArray(field.settings.models) === false) {
+    return [];
+  }
+
+  return field.settings.models;
+};
 
 const modelIdToTypeName = new Map();
 const plugin = {
@@ -83,14 +96,20 @@ const plugin = {
           cms
         } = context; // Get field value for this entry
 
-        const value = parent[field.fieldId];
+        const initialValue = parent[field.fieldId];
 
-        if (!value) {
+        if (!initialValue) {
           return null;
         }
 
         if (field.multipleValues) {
-          if (!value.length) {
+          /**
+           * We cast because value really can be array and single value.
+           * At this point, we are 99% sure that it is an array (+ we check for it)
+           */
+          const value = initialValue;
+
+          if (Array.isArray(value) === false || value.length === 0) {
             return [];
           }
 
@@ -120,8 +139,9 @@ const plugin = {
             return appendTypename(entries, modelIdToTypeName.get(modelId));
           });
           return await Promise.all(getters).then(results => results.reduce((result, item) => result.concat(item), []));
-        } // Get model manager, to get access to CRUD methods
+        }
 
+        const value = initialValue; // Get model manager, to get access to CRUD methods
 
         const model = await cms.getModelManager(value.modelId);
         let revisions; // `read` API works with `published` data
@@ -164,7 +184,7 @@ const plugin = {
       const unionFieldsTypeDef = unionFields.map(({
         field,
         typeName
-      }) => `union ${typeName} = ${field.settings.models.map(({
+      }) => `union ${typeName} = ${getFieldModels(field).map(({
         modelId
       }) => (0, _createTypeName.createReadTypeName)(modelId)).join(" | ")}`).join("\n");
       const filteringTypeDef = `

package/content/plugins/internalSecurity/InternalAuthenticationPlugin.d.ts

@@ -2,7 +2,7 @@ import { AuthenticationPlugin } from "@webiny/api-security/plugins/Authenticatio
 import { SecurityIdentity } from "@webiny/api-security/types";
 import { CmsContext } from "../../../types";
 export declare class InternalAuthenticationPlugin extends AuthenticationPlugin {
-    private _identityType;
+    private readonly _identityType;
     constructor(identityType: string);
     authenticate(context: CmsContext): Promise<undefined | SecurityIdentity>;
 }

package/content/plugins/internalSecurity/InternalAuthenticationPlugin.js

@@ -11,6 +11,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _AuthenticationPlugin = require("@webiny/api-security/plugins/AuthenticationPlugin");
 
+// TODO @ts-refactor @pavel
 // @ts-nocheck
 class InternalAuthenticationPlugin extends _AuthenticationPlugin.AuthenticationPlugin {
   constructor(identityType) {

package/content/plugins/internalSecurity/InternalAuthorizationPlugin.d.ts

@@ -1,7 +1,7 @@
 import { AuthorizationPlugin } from "@webiny/api-security/plugins/AuthorizationPlugin";
 import { CmsContext } from "../../../types";
 export declare class InternalAuthorizationPlugin extends AuthorizationPlugin {
-    private _identityType;
+    private readonly _identityType;
     constructor(identityType: string);
     getPermissions(context: CmsContext): any;
 }

package/content/plugins/internalSecurity/InternalAuthorizationPlugin.js

@@ -11,6 +11,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _AuthorizationPlugin = require("@webiny/api-security/plugins/AuthorizationPlugin");
 
+// TODO @ts-refactor @pavel
 // @ts-nocheck
 class InternalAuthorizationPlugin extends _AuthorizationPlugin.AuthorizationPlugin {
   constructor(identityType) {

package/content/plugins/modelManager/DefaultCmsModelManager.d.ts

@@ -1,14 +1,14 @@
-import { CmsModelManager, CmsModel, CmsContext, CmsEntryListParams } from "../../../types";
+import { CmsModelManager, CmsModel, CmsContext, CmsEntryListParams, CreateCmsEntryInput, UpdateCmsEntryInput } from "../../../types";
 export declare class DefaultCmsModelManager implements CmsModelManager {
     private readonly _context;
     private readonly _model;
     constructor(context: CmsContext, model: CmsModel);
-    create(data: any): Promise<import("../../../types").CmsEntry>;
+    create(data: CreateCmsEntryInput): Promise<import("../../../types").CmsEntry>;
     delete(id: string): Promise<void>;
     get(id: string): Promise<import("../../../types").CmsEntry>;
     listPublished(params: CmsEntryListParams): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
     listLatest(params: CmsEntryListParams): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
     getPublishedByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
     getLatestByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
-    update(id: any, data: any): Promise<import("../../../types").CmsEntry>;
+    update(id: string, data: UpdateCmsEntryInput): Promise<import("../../../types").CmsEntry>;
 }

package/content/plugins/schema/createFieldResolvers.d.ts

@@ -1,4 +1,4 @@
-import { CmsModelField } from "../../../types";
+import { CmsModelField, ApiEndpoint, CmsModel, CmsFieldTypePlugins } from "../../../types";
 import { Resolvers } from "@webiny/handler-graphql/types";
 interface CreateFieldResolvers {
     graphQLType: string;
@@ -6,14 +6,15 @@ interface CreateFieldResolvers {
     isRoot: boolean;
     extraResolvers?: Resolvers<any>;
 }
+interface CreateFieldResolversFactoryParams {
+    endpointType: ApiEndpoint;
+    models: CmsModel[];
+    model: CmsModel;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
 /**
  * We use a factory to avoid passing the parameters for recursive invocations.
  * This way they will always be in the function scope and we can only pass "fields".
  */
-export declare function createFieldResolversFactory({ endpointType, models, model, fieldTypePlugins }: {
-    endpointType: any;
-    models: any;
-    model: any;
-    fieldTypePlugins: any;
-}): (params: CreateFieldResolvers) => {};
+export declare const createFieldResolversFactory: (factoryParams: CreateFieldResolversFactoryParams) => (params: CreateFieldResolvers) => {};
 export {};

package/content/plugins/schema/createFieldResolvers.js

@@ -5,12 +5,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createFieldResolversFactory = createFieldResolversFactory;
+exports.createFieldResolversFactory = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _get = _interopRequireDefault(require("lodash/get"));
-
 var _set = _interopRequireDefault(require("lodash/set"));
 
 var _entryStorage = require("../utils/entryStorage");
@@ -19,16 +17,28 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
+const getCreateResolver = (plugins, field, endpointType) => {
+  if (!plugins[field.type]) {
+    return null;
+  } else if (!plugins[field.type][endpointType]) {
+    return null;
+  }
+
+  return plugins[field.type][endpointType].createResolver;
+};
 /**
  * We use a factory to avoid passing the parameters for recursive invocations.
  * This way they will always be in the function scope and we can only pass "fields".
  */
-function createFieldResolversFactory({
-  endpointType,
-  models,
-  model,
-  fieldTypePlugins
-}) {
+
+
+const createFieldResolversFactory = factoryParams => {
+  const {
+    endpointType,
+    models,
+    model,
+    fieldTypePlugins
+  } = factoryParams;
   return function createFieldResolvers(params) {
     const {
       graphQLType,
@@ -46,7 +56,7 @@ function createFieldResolversFactory({
         continue;
       }
 
-      const createResolver = (0, _get.default)(fieldTypePlugins, `${field.type}.${endpointType}.createResolver`);
+      const createResolver = getCreateResolver(fieldTypePlugins, field, endpointType);
       let resolver;
       const fieldResolver = createResolver ? createResolver({
         graphQLType,
@@ -71,7 +81,8 @@ function createFieldResolversFactory({
 
       const {
         fieldId
-      } = field;
+      } = field; // TODO @ts-refactor figure out types for parameters
+      // @ts-ignore
 
       fieldResolvers[fieldId] = async (parent, args, context, info) => {
         // Get transformed value (eg. data decompression)
@@ -95,4 +106,6 @@ function createFieldResolversFactory({
       [graphQLType]: fieldResolvers
     }, typeResolvers);
   };
-}
+};
+
+exports.createFieldResolversFactory = createFieldResolversFactory;

package/content/plugins/schema/createManageResolvers.d.ts

@@ -1,11 +1,12 @@
 import { CmsModel, CmsFieldTypePlugins, CmsContext } from "../../../types";
+interface CreateManageResolversParams {
+    models: CmsModel[];
+    model: CmsModel;
+    context: CmsContext;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
 interface CreateManageResolvers {
-    (params: {
-        models: CmsModel[];
-        model: CmsModel;
-        context: CmsContext;
-        fieldTypePlugins: CmsFieldTypePlugins;
-    }): any;
+    (params: CreateManageResolversParams): any;
 }
 export declare const createManageResolvers: CreateManageResolvers;
 export {};

package/content/plugins/schema/createManageSDL.d.ts

@@ -1,9 +1,10 @@
 import { CmsFieldTypePlugins, CmsModel } from "../../../types";
+interface CreateManageSDLParams {
+    model: CmsModel;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
 interface CreateManageSDL {
-    (params: {
-        model: CmsModel;
-        fieldTypePlugins: CmsFieldTypePlugins;
-    }): string;
+    (params: CreateManageSDLParams): string;
 }
 export declare const createManageSDL: CreateManageSDL;
 export {};

package/content/plugins/schema/createPreviewResolvers.d.ts

@@ -1,10 +1,12 @@
 import { CmsModel, CmsFieldTypePlugins, CmsContext } from "../../../types";
+interface CreateReadResolversParams {
+    models: CmsModel[];
+    model: CmsModel;
+    context: CmsContext;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
 export interface CreateReadResolvers {
-    (params: {
-        models: CmsModel[];
-        model: CmsModel;
-        context: CmsContext;
-        fieldTypePlugins: CmsFieldTypePlugins;
-    }): any;
+    (params: CreateReadResolversParams): any;
 }
 export declare const createPreviewResolvers: CreateReadResolvers;
+export {};