@webiny/api-headless-cms 0.0.0-mt-2 → 0.0.0-unstable.1145e7667f

package/utils/converters/valueKeyStorageConverter.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createValueKeyToStorageConverter = exports.createValueKeyFromStorageConverter = exports.createCmsModelFieldConvertersAttachFactory = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _ConverterCollection = require("./ConverterCollection");
+var _semver = _interopRequireDefault(require("semver"));
+const featureVersion = _semver.default.coerce("5.33.0");
+const isBetaOrNext = model => {
+  if (!model.webinyVersion) {
+    return false;
+  }
+  return model.webinyVersion.match(/next|beta/) !== null;
+};
+const isFeatureEnabled = model => {
+  /**
+   * In case of disabled webinyVersion value, we disable this feature.
+   * This is only for testing...
+   */
+  if (model.webinyVersion === "disable") {
+    return false;
+  }
+  /**
+   * If is a test environment, always have this turned on.
+   */
+  const nodeEnv = process.env.NODE_ENV;
+  if (nodeEnv === "test" || nodeEnv === "disable" || isBetaOrNext(model)) {
+    return true;
+  }
+  /**
+   * Possibility that the version is not defined, this means it is a quite old system where models did not change.
+   */
+  if (!model.webinyVersion) {
+    return false;
+  }
+  /**
+   * In case feature version value is greater than the model version, feature is not enabled as it is an older model with no storageId.
+   *
+   * TODO change if necessary after the update to the system
+   */
+  const modelVersion = _semver.default.coerce(model.webinyVersion);
+  if (!modelVersion) {
+    console.log(`Warning: Model "${model.modelId}" does not have valid Webiny version set.`);
+    return true;
+  } else if (_semver.default.compare(modelVersion, featureVersion) === -1) {
+    return false;
+  }
+  return true;
+};
+const createValueKeyToStorageConverter = params => {
+  const {
+    plugins,
+    model
+  } = params;
+  if (isFeatureEnabled(model) === false) {
+    return ({
+      values
+    }) => {
+      return values || {};
+    };
+  }
+  const converters = new _ConverterCollection.ConverterCollection({
+    plugins
+  });
+  return ({
+    fields,
+    values
+  }) => {
+    const result = converters.convertToStorage({
+      fields: fields || model.fields,
+      values
+    });
+    return result || {};
+  };
+};
+exports.createValueKeyToStorageConverter = createValueKeyToStorageConverter;
+const createValueKeyFromStorageConverter = params => {
+  const {
+    plugins,
+    model
+  } = params;
+  if (isFeatureEnabled(model) === false) {
+    return ({
+      values
+    }) => {
+      return values || {};
+    };
+  }
+  const converters = new _ConverterCollection.ConverterCollection({
+    plugins
+  });
+  return ({
+    fields,
+    values
+  }) => {
+    const result = converters.convertFromStorage({
+      fields: fields || model.fields,
+      values
+    });
+    return result || {};
+  };
+};
+exports.createValueKeyFromStorageConverter = createValueKeyFromStorageConverter;
+const createCmsModelFieldConvertersAttachFactory = plugins => {
+  return model => {
+    const storageModel = model;
+    if (!!storageModel.convertValueKeyToStorage && !!storageModel.convertValueKeyFromStorage) {
+      return storageModel;
+    }
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+      convertValueKeyToStorage: createValueKeyToStorageConverter({
+        model,
+        plugins
+      }),
+      convertValueKeyFromStorage: createValueKeyFromStorageConverter({
+        model,
+        plugins
+      })
+    });
+  };
+};
+exports.createCmsModelFieldConvertersAttachFactory = createCmsModelFieldConvertersAttachFactory;

package/utils/converters/valueKeyStorageConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["featureVersion","semver","coerce","isBetaOrNext","model","webinyVersion","match","isFeatureEnabled","nodeEnv","process","env","NODE_ENV","modelVersion","console","log","modelId","compare","createValueKeyToStorageConverter","params","plugins","values","converters","ConverterCollection","fields","result","convertToStorage","createValueKeyFromStorageConverter","convertFromStorage","createCmsModelFieldConvertersAttachFactory","storageModel","convertValueKeyToStorage","convertValueKeyFromStorage"],"sources":["valueKeyStorageConverter.ts"],"sourcesContent":["import { PluginsContainer } from \"@webiny/plugins\";\nimport {\n    CmsModelConverterCallable,\n    ConverterCollection,\n    ConverterCollectionConvertParams as BaseConverterCollectionConvertParams\n} from \"~/utils/converters/ConverterCollection\";\nimport { CmsModel, StorageOperationsCmsModel } from \"~/types\";\nimport semver, { SemVer } from \"semver\";\n\nconst featureVersion = semver.coerce(\"5.33.0\") as SemVer;\n\nconst isBetaOrNext = (model: CmsModel): boolean => {\n    if (!model.webinyVersion) {\n        return false;\n    }\n    return model.webinyVersion.match(/next|beta/) !== null;\n};\n\nconst isFeatureEnabled = (model: CmsModel): boolean => {\n    /**\n     * In case of disabled webinyVersion value, we disable this feature.\n     * This is only for testing...\n     */\n    if (model.webinyVersion === \"disable\") {\n        return false;\n    }\n    /**\n     * If is a test environment, always have this turned on.\n     */\n    const nodeEnv = process.env.NODE_ENV as string;\n    if (nodeEnv === \"test\" || nodeEnv === \"disable\" || isBetaOrNext(model)) {\n        return true;\n    }\n    /**\n     * Possibility that the version is not defined, this means it is a quite old system where models did not change.\n     */\n    if (!model.webinyVersion) {\n        return false;\n    }\n    /**\n     * In case feature version value is greater than the model version, feature is not enabled as it is an older model with no storageId.\n     *\n     * TODO change if necessary after the update to the system\n     */\n    const modelVersion = semver.coerce(model.webinyVersion);\n    if (!modelVersion) {\n        console.log(`Warning: Model \"${model.modelId}\" does not have valid Webiny version set.`);\n        return true;\n    } else if (semver.compare(modelVersion, featureVersion) === -1) {\n        return false;\n    }\n    return true;\n};\n\ninterface Params {\n    /**\n     * We need a model to determine if the conversion feature is enabled.\n     */\n    model: CmsModel;\n    plugins: PluginsContainer;\n}\n\n/**\n * In the first call of the converter we do not need the fields property as it will be taken directly from the model.\n */\ninterface ConverterCollectionConvertParams\n    extends Omit<BaseConverterCollectionConvertParams, \"fields\"> {\n    fields?: BaseConverterCollectionConvertParams[\"fields\"];\n}\n\nexport const createValueKeyToStorageConverter = (params: Params): CmsModelConverterCallable => {\n    const { plugins, model } = params;\n\n    if (isFeatureEnabled(model) === false) {\n        return ({ values }: ConverterCollectionConvertParams) => {\n            return values || {};\n        };\n    }\n\n    const converters = new ConverterCollection({\n        plugins\n    });\n\n    return ({ fields, values }: ConverterCollectionConvertParams) => {\n        const result = converters.convertToStorage({\n            fields: fields || model.fields,\n            values\n        });\n        return result || {};\n    };\n};\n\nexport const createValueKeyFromStorageConverter = (params: Params): CmsModelConverterCallable => {\n    const { plugins, model } = params;\n\n    if (isFeatureEnabled(model) === false) {\n        return ({ values }: ConverterCollectionConvertParams) => {\n            return values || {};\n        };\n    }\n\n    const converters = new ConverterCollection({\n        plugins\n    });\n\n    return ({ fields, values }: ConverterCollectionConvertParams) => {\n        const result = converters.convertFromStorage({\n            fields: fields || model.fields,\n            values\n        });\n        return result || {};\n    };\n};\n\nexport const createCmsModelFieldConvertersAttachFactory = (plugins: PluginsContainer) => {\n    return (model: StorageOperationsCmsModel | CmsModel): StorageOperationsCmsModel => {\n        const storageModel = model as Partial<StorageOperationsCmsModel>;\n        if (!!storageModel.convertValueKeyToStorage && !!storageModel.convertValueKeyFromStorage) {\n            return storageModel as StorageOperationsCmsModel;\n        }\n        return {\n            ...model,\n            convertValueKeyToStorage: createValueKeyToStorageConverter({\n                model,\n                plugins\n            }),\n            convertValueKeyFromStorage: createValueKeyFromStorageConverter({\n                model,\n                plugins\n            })\n        };\n    };\n};\n"],"mappings":"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"}

package/utils/createTypeFromFields.d.ts

@@ -0,0 +1,16 @@
+import { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField } from "../types";
+interface TypeFromFieldParams {
+    typeOfType: "type" | "input";
+    models: CmsModel[];
+    model: CmsModel;
+    type: ApiEndpoint;
+    typeNamePrefix: string;
+    fields: CmsModelField[];
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
+interface TypeFromFieldResponse {
+    fieldType: string;
+    typeDefs: string;
+}
+export declare const createTypeFromFields: (params: TypeFromFieldParams) => TypeFromFieldResponse | null;
+export {};

package/utils/createTypeFromFields.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeFromFields = void 0;
+var _renderFields = require("./renderFields");
+var _renderInputFields = require("./renderInputFields");
+const createTypeFromFields = params => {
+  const {
+    typeOfType,
+    model,
+    models,
+    type,
+    typeNamePrefix,
+    fields,
+    fieldTypePlugins
+  } = params;
+  const typeSuffix = typeOfType === "input" ? "Input" : "";
+  const mTypeName = model.singularApiName;
+  const typeFields = [];
+  const nestedTypes = [];
+
+  // Once the loop below starts, we'll be executing a recursive "object" type generation.
+  // The main trick here is that nested objects don't know who the parent is, and will generate
+  // type names using the "model", as if they're at the top level:
+  // Every time the types are returned, we need to replace the model name in the generated type name
+  // with the actual prefix which includes parent field name type.
+  const replace = new RegExp(`${mTypeName}_`, "g");
+  for (const field of fields) {
+    const result = typeOfType === "type" ? (0, _renderFields.renderField)({
+      field,
+      type,
+      models,
+      model,
+      fieldTypePlugins
+    }) : (0, _renderInputFields.renderInputField)({
+      field,
+      models,
+      model,
+      fieldTypePlugins
+    });
+    if (!result) {
+      continue;
+    }
+    const {
+      fields,
+      typeDefs
+    } = result;
+    typeFields.push(fields.replace(replace, `${typeNamePrefix}_`));
+    if (typeDefs) {
+      nestedTypes.push(typeDefs.replace(replace, `${typeNamePrefix}_`));
+    }
+  }
+  return {
+    fieldType: `${typeNamePrefix}${typeSuffix}`,
+    typeDefs: /* GraphQL */`
+            ${nestedTypes.join("\n")}
+
+            ${typeOfType} ${typeNamePrefix}${typeSuffix} {
+                ${typeFields.join("\n")}
+            }
+        `
+  };
+};
+exports.createTypeFromFields = createTypeFromFields;

package/utils/createTypeFromFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createTypeFromFields","params","typeOfType","model","models","type","typeNamePrefix","fields","fieldTypePlugins","typeSuffix","mTypeName","singularApiName","typeFields","nestedTypes","replace","RegExp","field","result","renderField","renderInputField","typeDefs","push","fieldType","join"],"sources":["createTypeFromFields.ts"],"sourcesContent":["import { renderField } from \"~/utils/renderFields\";\nimport { renderInputField } from \"~/utils/renderInputFields\";\nimport { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField } from \"~/types\";\n\ninterface TypeFromFieldParams {\n    typeOfType: \"type\" | \"input\";\n    models: CmsModel[];\n    model: CmsModel;\n    type: ApiEndpoint;\n    typeNamePrefix: string;\n    fields: CmsModelField[];\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\n\ninterface TypeFromFieldResponse {\n    fieldType: string;\n    typeDefs: string;\n}\n\nexport const createTypeFromFields = (params: TypeFromFieldParams): TypeFromFieldResponse | null => {\n    const { typeOfType, model, models, type, typeNamePrefix, fields, fieldTypePlugins } = params;\n    const typeSuffix = typeOfType === \"input\" ? \"Input\" : \"\";\n    const mTypeName = model.singularApiName;\n\n    const typeFields: string[] = [];\n    const nestedTypes: string[] = [];\n\n    // Once the loop below starts, we'll be executing a recursive \"object\" type generation.\n    // The main trick here is that nested objects don't know who the parent is, and will generate\n    // type names using the \"model\", as if they're at the top level:\n    // Every time the types are returned, we need to replace the model name in the generated type name\n    // with the actual prefix which includes parent field name type.\n    const replace = new RegExp(`${mTypeName}_`, \"g\");\n\n    for (const field of fields) {\n        const result =\n            typeOfType === \"type\"\n                ? renderField({ field, type, models, model, fieldTypePlugins })\n                : renderInputField({ field, models, model, fieldTypePlugins });\n\n        if (!result) {\n            continue;\n        }\n\n        const { fields, typeDefs } = result;\n\n        typeFields.push(fields.replace(replace, `${typeNamePrefix}_`));\n        if (typeDefs) {\n            nestedTypes.push(typeDefs.replace(replace, `${typeNamePrefix}_`));\n        }\n    }\n\n    return {\n        fieldType: `${typeNamePrefix}${typeSuffix}`,\n        typeDefs: /* GraphQL */ `\n            ${nestedTypes.join(\"\\n\")}\n\n            ${typeOfType} ${typeNamePrefix}${typeSuffix} {\n                ${typeFields.join(\"\\n\")}\n            }\n        `\n    };\n};\n"],"mappings":";;;;;;AAAA;AACA;AAkBO,MAAMA,oBAAoB,GAAIC,MAA2B,IAAmC;EAC/F,MAAM;IAAEC,UAAU;IAAEC,KAAK;IAAEC,MAAM;IAAEC,IAAI;IAAEC,cAAc;IAAEC,MAAM;IAAEC;EAAiB,CAAC,GAAGP,MAAM;EAC5F,MAAMQ,UAAU,GAAGP,UAAU,KAAK,OAAO,GAAG,OAAO,GAAG,EAAE;EACxD,MAAMQ,SAAS,GAAGP,KAAK,CAACQ,eAAe;EAEvC,MAAMC,UAAoB,GAAG,EAAE;EAC/B,MAAMC,WAAqB,GAAG,EAAE;;EAEhC;EACA;EACA;EACA;EACA;EACA,MAAMC,OAAO,GAAG,IAAIC,MAAM,CAAE,GAAEL,SAAU,GAAE,EAAE,GAAG,CAAC;EAEhD,KAAK,MAAMM,KAAK,IAAIT,MAAM,EAAE;IACxB,MAAMU,MAAM,GACRf,UAAU,KAAK,MAAM,GACf,IAAAgB,yBAAW,EAAC;MAAEF,KAAK;MAAEX,IAAI;MAAED,MAAM;MAAED,KAAK;MAAEK;IAAiB,CAAC,CAAC,GAC7D,IAAAW,mCAAgB,EAAC;MAAEH,KAAK;MAAEZ,MAAM;MAAED,KAAK;MAAEK;IAAiB,CAAC,CAAC;IAEtE,IAAI,CAACS,MAAM,EAAE;MACT;IACJ;IAEA,MAAM;MAAEV,MAAM;MAAEa;IAAS,CAAC,GAAGH,MAAM;IAEnCL,UAAU,CAACS,IAAI,CAACd,MAAM,CAACO,OAAO,CAACA,OAAO,EAAG,GAAER,cAAe,GAAE,CAAC,CAAC;IAC9D,IAAIc,QAAQ,EAAE;MACVP,WAAW,CAACQ,IAAI,CAACD,QAAQ,CAACN,OAAO,CAACA,OAAO,EAAG,GAAER,cAAe,GAAE,CAAC,CAAC;IACrE;EACJ;EAEA,OAAO;IACHgB,SAAS,EAAG,GAAEhB,cAAe,GAAEG,UAAW,EAAC;IAC3CW,QAAQ,EAAE,aAAe;AACjC,cAAcP,WAAW,CAACU,IAAI,CAAC,IAAI,CAAE;AACrC;AACA,cAAcrB,UAAW,IAAGI,cAAe,GAAEG,UAAW;AACxD,kBAAkBG,UAAU,CAACW,IAAI,CAAC,IAAI,CAAE;AACxC;AACA;EACI,CAAC;AACL,CAAC;AAAC"}

package/utils/createTypeName.d.ts

@@ -0,0 +1 @@
+export declare const createTypeName: (modelId: string) => string;

package/utils/createTypeName.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeName = void 0;
+var _upperFirst = _interopRequireDefault(require("lodash/upperFirst"));
+var _camelCase = _interopRequireDefault(require("lodash/camelCase"));
+const createTypeName = modelId => {
+  return (0, _upperFirst.default)((0, _camelCase.default)(modelId));
+};
+exports.createTypeName = createTypeName;

package/utils/createTypeName.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createTypeName","modelId","upperFirst","camelCase"],"sources":["createTypeName.ts"],"sourcesContent":["import upperFirst from \"lodash/upperFirst\";\nimport camelCase from \"lodash/camelCase\";\n\nexport const createTypeName = (modelId: string): string => {\n    return upperFirst(camelCase(modelId));\n};\n"],"mappings":";;;;;;;AAAA;AACA;AAEO,MAAMA,cAAc,GAAIC,OAAe,IAAa;EACvD,OAAO,IAAAC,mBAAU,EAAC,IAAAC,kBAAS,EAACF,OAAO,CAAC,CAAC;AACzC,CAAC;AAAC"}

package/{content/plugins/utils → utils}/entryStorage.d.ts

@@ -1,4 +1,4 @@
-import { CmsEntry, CmsModel, CmsModelField, CmsContext } from "../../../types";
+import { CmsEntry, CmsModel, CmsModelField, CmsContext } from "../types";
 /**
  * A function that is used in crud to transform entry into the storage type.
  */
@@ -6,12 +6,12 @@ export declare const entryToStorageTransform: (context: CmsContext, model: CmsMo
 /**
  * A function that is used to transform the whole entry from storage into its native form.
  */
-export declare const entryFromStorageTransform: (context: CmsContext, model: CmsModel, entry?: CmsEntry & Record<string, any>) => Promise<CmsEntry>;
+export declare const entryFromStorageTransform: (context: CmsContext, model: CmsModel, entry: CmsEntry) => Promise<CmsEntry>;
 interface EntryFieldFromStorageTransformParams {
     context: CmsContext;
     model: CmsModel;
     field: CmsModelField;
     value: any;
 }
-export declare const entryFieldFromStorageTransform: (params: EntryFieldFromStorageTransformParams) => Promise<any>;
+export declare const entryFieldFromStorageTransform: <T = any>(params: EntryFieldFromStorageTransformParams) => Promise<T>;
 export {};

package/{content/plugins/utils → utils}/entryStorage.js

@@ -1,63 +1,52 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.entryToStorageTransform = exports.entryFromStorageTransform = exports.entryFieldFromStorageTransform = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _StorageTransformPlugin = require("../storage/StorageTransformPlugin");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
+var _StorageTransformPlugin = require("../plugins/StorageTransformPlugin");
+var _getBaseFieldType = require("./getBaseFieldType");
 const getStoragePluginFactory = context => {
   let defaultStoragePlugin;
-  const plugins = context.plugins.byType(_StorageTransformPlugin.StorageTransformPlugin.type) // we reverse plugins because we want to get latest added only
+  const plugins = context.plugins.byType(_StorageTransformPlugin.StorageTransformPlugin.type)
+  // we reverse plugins because we want to get latest added only
   .reverse().reduce((collection, plugin) => {
-    // check if it's a default plugin
-    if (plugin.fieldType === "*" && !defaultStoragePlugin) {
+    /**
+     * Check if it's a default plugin and set it - always override the previous one.
+     */
+    if (plugin.fieldType === "*") {
       defaultStoragePlugin = plugin;
       return collection;
     }
+
     /**
-     * either existing plugin added or plugin fieldType does not exist in current model
-     * this is to iterate a bit less later
+     * We will just set the plugin for given type.
+     * The last one will override existing one - so users can override our default ones.
      */
-
-
-    if (!collection[plugin.fieldType]) {
-      collection[plugin.fieldType] = plugin;
-    }
-
+    collection[plugin.fieldType] = plugin;
     return collection;
   }, {});
   return fieldType => {
     return plugins[fieldType] || defaultStoragePlugin;
   };
 };
+
 /**
  * This should be used when transforming the whole entry.
  */
-
-
 const entryStorageTransform = async (context, model, operation, entry) => {
   const getStoragePlugin = getStoragePluginFactory(context);
   const transformedValues = {};
-
   for (const field of model.fields) {
-    const plugin = getStoragePlugin(field.type); // TODO: remove this once plugins are converted into classes
-
+    const baseType = (0, _getBaseFieldType.getBaseFieldType)(field);
+    const plugin = getStoragePlugin(baseType);
+    // TODO: remove this once plugins are converted into classes
     if (typeof plugin[operation] !== "function") {
-      throw new _error.default(`Missing "${operation}" function in storage plugin "${plugin.name}" for field type "${field.type}"`);
+      throw new _error.default(`Missing "${operation}" function in storage plugin "${plugin.name}" for field type "${baseType}"`);
     }
-
     transformedValues[field.fieldId] = await plugin[operation]({
       plugins: context.plugins,
       model,
@@ -66,36 +55,26 @@ const entryStorageTransform = async (context, model, operation, entry) => {
       getStoragePlugin
     });
   }
-
-  return _objectSpread(_objectSpread({}, entry), {}, {
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
     values: transformedValues
   });
 };
+
 /**
  * A function that is used in crud to transform entry into the storage type.
  */
-
-
 const entryToStorageTransform = async (context, model, entry) => {
   return entryStorageTransform(context, model, "toStorage", entry);
 };
+
 /**
  * A function that is used to transform the whole entry from storage into its native form.
  */
-
-
 exports.entryToStorageTransform = entryToStorageTransform;
-
 const entryFromStorageTransform = async (context, model, entry) => {
-  if (!entry) {
-    return null;
-  }
-
   return entryStorageTransform(context, model, "fromStorage", entry);
 };
-
 exports.entryFromStorageTransform = entryFromStorageTransform;
-
 /*
  * A function that is used to transform a single field from storage
  */
@@ -107,12 +86,13 @@ const entryFieldFromStorageTransform = async params => {
     value
   } = params;
   const getStoragePlugin = getStoragePluginFactory(context);
-  const plugin = getStoragePlugin(field.type); // TODO: remove this once plugins are converted into classes
+  const baseType = (0, _getBaseFieldType.getBaseFieldType)(field);
+  const plugin = getStoragePlugin(baseType);
 
+  // TODO: remove this once plugins are converted into classes
   if (typeof plugin.fromStorage !== "function") {
-    throw new _error.default(`Missing "fromStorage" function in storage plugin "${plugin.name}" for field type "${field.type}"`);
+    throw new _error.default(`Missing "fromStorage" function in storage plugin "${plugin.name}" for field type "${baseType}"`);
   }
-
   return plugin.fromStorage({
     plugins: context.plugins,
     model,
@@ -121,5 +101,4 @@ const entryFieldFromStorageTransform = async params => {
     getStoragePlugin
   });
 };
-
 exports.entryFieldFromStorageTransform = entryFieldFromStorageTransform;

package/utils/entryStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getStoragePluginFactory","context","defaultStoragePlugin","plugins","byType","StorageTransformPlugin","type","reverse","reduce","collection","plugin","fieldType","entryStorageTransform","model","operation","entry","getStoragePlugin","transformedValues","field","fields","baseType","getBaseFieldType","WebinyError","name","fieldId","value","values","entryToStorageTransform","entryFromStorageTransform","entryFieldFromStorageTransform","params","fromStorage"],"sources":["entryStorage.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { StorageTransformPlugin } from \"~/plugins/StorageTransformPlugin\";\nimport { CmsEntry, CmsModel, CmsModelField, CmsContext } from \"~/types\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType\";\n\ninterface GetStoragePluginFactory {\n    (context: CmsContext): (fieldType: string) => StorageTransformPlugin<any>;\n}\n\nconst getStoragePluginFactory: GetStoragePluginFactory = context => {\n    let defaultStoragePlugin: StorageTransformPlugin;\n\n    const plugins = context.plugins\n        .byType<StorageTransformPlugin>(StorageTransformPlugin.type)\n        // we reverse plugins because we want to get latest added only\n        .reverse()\n        .reduce((collection, plugin) => {\n            /**\n             * Check if it's a default plugin and set it - always override the previous one.\n             */\n            if (plugin.fieldType === \"*\") {\n                defaultStoragePlugin = plugin;\n                return collection;\n            }\n\n            /**\n             * We will just set the plugin for given type.\n             * The last one will override existing one - so users can override our default ones.\n             */\n            collection[plugin.fieldType] = plugin;\n\n            return collection;\n        }, {} as Record<string, StorageTransformPlugin>);\n\n    return (fieldType: string) => {\n        return plugins[fieldType] || defaultStoragePlugin;\n    };\n};\n\n/**\n * This should be used when transforming the whole entry.\n */\nconst entryStorageTransform = async (\n    context: CmsContext,\n    model: CmsModel,\n    operation: \"toStorage\" | \"fromStorage\",\n    entry: CmsEntry\n): Promise<CmsEntry> => {\n    const getStoragePlugin = getStoragePluginFactory(context);\n\n    const transformedValues: Record<string, any> = {};\n    for (const field of model.fields) {\n        const baseType = getBaseFieldType(field);\n        const plugin = getStoragePlugin(baseType);\n        // TODO: remove this once plugins are converted into classes\n        if (typeof plugin[operation] !== \"function\") {\n            throw new WebinyError(\n                `Missing \"${operation}\" function in storage plugin \"${plugin.name}\" for field type \"${baseType}\"`\n            );\n        }\n\n        transformedValues[field.fieldId] = await plugin[operation]({\n            plugins: context.plugins,\n            model,\n            field,\n            value: entry.values[field.fieldId],\n            getStoragePlugin\n        });\n    }\n\n    return { ...entry, values: transformedValues };\n};\n\n/**\n * A function that is used in crud to transform entry into the storage type.\n */\nexport const entryToStorageTransform = async (\n    context: CmsContext,\n    model: CmsModel,\n    entry: CmsEntry\n): Promise<CmsEntry> => {\n    return entryStorageTransform(context, model, \"toStorage\", entry);\n};\n\n/**\n * A function that is used to transform the whole entry from storage into its native form.\n */\nexport const entryFromStorageTransform = async (\n    context: CmsContext,\n    model: CmsModel,\n    entry: CmsEntry\n): Promise<CmsEntry> => {\n    return entryStorageTransform(context, model, \"fromStorage\", entry);\n};\n\ninterface EntryFieldFromStorageTransformParams {\n    context: CmsContext;\n    model: CmsModel;\n    field: CmsModelField;\n    value: any;\n}\n/*\n * A function that is used to transform a single field from storage\n */\nexport const entryFieldFromStorageTransform = async <T = any>(\n    params: EntryFieldFromStorageTransformParams\n): Promise<T> => {\n    const { context, model, field, value } = params;\n    const getStoragePlugin = getStoragePluginFactory(context);\n\n    const baseType = getBaseFieldType(field);\n    const plugin = getStoragePlugin(baseType);\n\n    // TODO: remove this once plugins are converted into classes\n    if (typeof plugin.fromStorage !== \"function\") {\n        throw new WebinyError(\n            `Missing \"fromStorage\" function in storage plugin \"${plugin.name}\" for field type \"${baseType}\"`\n        );\n    }\n\n    return plugin.fromStorage({\n        plugins: context.plugins,\n        model,\n        field,\n        value,\n        getStoragePlugin\n    });\n};\n"],"mappings":"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"}

package/utils/filterAsync.d.ts

@@ -0,0 +1 @@
+export declare const filterAsync: <T = Record<string, any>>(items: T[], predicate: (param: T) => Promise<boolean>) => Promise<T[]>;

package/utils/filterAsync.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterAsync = void 0;
+const filterAsync = async (items, predicate) => {
+  const filteredItems = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const valid = await predicate(item);
+    if (valid) {
+      filteredItems.push(item);
+    }
+  }
+  return filteredItems;
+};
+exports.filterAsync = filterAsync;

package/utils/filterAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["filterAsync","items","predicate","filteredItems","i","length","item","valid","push"],"sources":["filterAsync.ts"],"sourcesContent":["export const filterAsync = async <T = Record<string, any>>(\n    items: T[],\n    predicate: (param: T) => Promise<boolean>\n): Promise<T[]> => {\n    const filteredItems = [];\n\n    for (let i = 0; i < items.length; i++) {\n        const item = items[i];\n        const valid = await predicate(item);\n        if (valid) {\n            filteredItems.push(item);\n        }\n    }\n\n    return filteredItems;\n};\n"],"mappings":";;;;;;AAAO,MAAMA,WAAW,GAAG,OACvBC,KAAU,EACVC,SAAyC,KAC1B;EACf,MAAMC,aAAa,GAAG,EAAE;EAExB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,KAAK,CAACI,MAAM,EAAED,CAAC,EAAE,EAAE;IACnC,MAAME,IAAI,GAAGL,KAAK,CAACG,CAAC,CAAC;IACrB,MAAMG,KAAK,GAAG,MAAML,SAAS,CAACI,IAAI,CAAC;IACnC,IAAIC,KAAK,EAAE;MACPJ,aAAa,CAACK,IAAI,CAACF,IAAI,CAAC;IAC5B;EACJ;EAEA,OAAOH,aAAa;AACxB,CAAC;AAAC"}

package/utils/getBaseFieldType.d.ts

@@ -0,0 +1,4 @@
+import { CmsModelField } from "../types";
+export declare const getBaseFieldType: (field: {
+    type: CmsModelField["type"];
+}) => string;

package/utils/getBaseFieldType.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBaseFieldType = void 0;
+const getBaseFieldType = field => {
+  return field.type.split(":")[0];
+};
+exports.getBaseFieldType = getBaseFieldType;

package/utils/getBaseFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getBaseFieldType","field","type","split"],"sources":["getBaseFieldType.ts"],"sourcesContent":["import { CmsModelField } from \"~/types\";\n\nexport const getBaseFieldType = (field: { type: CmsModelField[\"type\"] }) => {\n    return field.type.split(\":\")[0];\n};\n"],"mappings":";;;;;;AAEO,MAAMA,gBAAgB,GAAIC,KAAsC,IAAK;EACxE,OAAOA,KAAK,CAACC,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACnC,CAAC;AAAC"}

package/utils/getEntryDescription.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntry, CmsModel } from "../types";
+export declare function getEntryDescription(model: CmsModel, entry: CmsEntry): string;

package/utils/getEntryDescription.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEntryDescription = getEntryDescription;
+function getEntryDescription(model, entry) {
+  if (!model.descriptionFieldId) {
+    return "";
+  }
+  const field = model.fields.find(f => f.fieldId === model.descriptionFieldId);
+  if (!field) {
+    return "";
+  }
+  const descriptionFieldId = field.fieldId;
+  return entry.values[descriptionFieldId] || "";
+}

package/utils/getEntryDescription.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getEntryDescription","model","entry","descriptionFieldId","field","fields","find","f","fieldId","values"],"sources":["getEntryDescription.ts"],"sourcesContent":["import { CmsEntry, CmsModel } from \"~/types\";\n\nexport function getEntryDescription(model: CmsModel, entry: CmsEntry): string {\n    if (!model.descriptionFieldId) {\n        return \"\";\n    }\n    const field = model.fields.find(f => f.fieldId === model.descriptionFieldId);\n    if (!field) {\n        return \"\";\n    }\n    const descriptionFieldId = field.fieldId;\n    return entry.values[descriptionFieldId] || \"\";\n}\n"],"mappings":";;;;;;AAEO,SAASA,mBAAmB,CAACC,KAAe,EAAEC,KAAe,EAAU;EAC1E,IAAI,CAACD,KAAK,CAACE,kBAAkB,EAAE;IAC3B,OAAO,EAAE;EACb;EACA,MAAMC,KAAK,GAAGH,KAAK,CAACI,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKP,KAAK,CAACE,kBAAkB,CAAC;EAC5E,IAAI,CAACC,KAAK,EAAE;IACR,OAAO,EAAE;EACb;EACA,MAAMD,kBAAkB,GAAGC,KAAK,CAACI,OAAO;EACxC,OAAON,KAAK,CAACO,MAAM,CAACN,kBAAkB,CAAC,IAAI,EAAE;AACjD"}

package/utils/getEntryImage.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntry, CmsModel } from "../types";
+export declare function getEntryImage(model: CmsModel, entry: CmsEntry): string | null;

package/utils/getEntryImage.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEntryImage = getEntryImage;
+function getEntryImage(model, entry) {
+  if (!model.imageFieldId) {
+    return null;
+  }
+  const field = model.fields.find(f => f.fieldId === model.imageFieldId);
+  if (!field) {
+    return null;
+  }
+  const imageFieldId = field.fieldId;
+  return entry.values[imageFieldId] || null;
+}

package/utils/getEntryImage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getEntryImage","model","entry","imageFieldId","field","fields","find","f","fieldId","values"],"sources":["getEntryImage.ts"],"sourcesContent":["import { CmsEntry, CmsModel } from \"~/types\";\n\nexport function getEntryImage(model: CmsModel, entry: CmsEntry): string | null {\n    if (!model.imageFieldId) {\n        return null;\n    }\n    const field = model.fields.find(f => f.fieldId === model.imageFieldId);\n    if (!field) {\n        return null;\n    }\n    const imageFieldId = field.fieldId;\n    return entry.values[imageFieldId] || null;\n}\n"],"mappings":";;;;;;AAEO,SAASA,aAAa,CAACC,KAAe,EAAEC,KAAe,EAAiB;EAC3E,IAAI,CAACD,KAAK,CAACE,YAAY,EAAE;IACrB,OAAO,IAAI;EACf;EACA,MAAMC,KAAK,GAAGH,KAAK,CAACI,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKP,KAAK,CAACE,YAAY,CAAC;EACtE,IAAI,CAACC,KAAK,EAAE;IACR,OAAO,IAAI;EACf;EACA,MAAMD,YAAY,GAAGC,KAAK,CAACI,OAAO;EAClC,OAAON,KAAK,CAACO,MAAM,CAACN,YAAY,CAAC,IAAI,IAAI;AAC7C"}

package/utils/getEntryTitle.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntry, CmsModel } from "../types";
+export declare function getEntryTitle(model: CmsModel, entry: CmsEntry): string;

package/{content/plugins/utils → utils}/getEntryTitle.js

@@ -4,39 +4,31 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getEntryTitle = getEntryTitle;
-
 function getEntryTitle(model, entry) {
   if (!model.titleFieldId) {
     return entry.id;
   }
-
-  const titleValue = entry.values[model.titleFieldId];
-
-  if (!titleValue) {
-    return entry.id;
-  }
-
   const field = model.fields.find(f => f.fieldId === model.titleFieldId);
-
   if (!field) {
-    return titleValue;
+    return entry.id;
+  }
+  const titleFieldId = field.fieldId;
+  const titleValue = entry.values[titleFieldId];
+  if (!titleValue) {
+    return entry.id;
   }
-
   const {
     enabled = false,
     values
   } = field.predefinedValues || {};
-
-  if (!enabled || Array.isArray(values) === false) {
+  if (!enabled || !values || Array.isArray(values) === false) {
     return titleValue;
   }
-
   for (const value of values) {
     // needs to be loose because titleValue can be a number and value can be a string - but it must match
     if (value.value == titleValue) {
       return value.label;
     }
   }
-
   return titleValue;
 }

package/utils/getEntryTitle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getEntryTitle","model","entry","titleFieldId","id","field","fields","find","f","fieldId","titleValue","values","enabled","predefinedValues","Array","isArray","value","label"],"sources":["getEntryTitle.ts"],"sourcesContent":["import { CmsEntry, CmsModel } from \"~/types\";\n\nexport function getEntryTitle(model: CmsModel, entry: CmsEntry): string {\n    if (!model.titleFieldId) {\n        return entry.id;\n    }\n    const field = model.fields.find(f => f.fieldId === model.titleFieldId);\n    if (!field) {\n        return entry.id;\n    }\n    const titleFieldId = field.fieldId;\n    const titleValue = entry.values[titleFieldId];\n    if (!titleValue) {\n        return entry.id;\n    }\n\n    const { enabled = false, values } = field.predefinedValues || {};\n    if (!enabled || !values || Array.isArray(values) === false) {\n        return titleValue;\n    }\n    for (const value of values) {\n        // needs to be loose because titleValue can be a number and value can be a string - but it must match\n        if (value.value == titleValue) {\n            return value.label;\n        }\n    }\n    return titleValue;\n}\n"],"mappings":";;;;;;AAEO,SAASA,aAAa,CAACC,KAAe,EAAEC,KAAe,EAAU;EACpE,IAAI,CAACD,KAAK,CAACE,YAAY,EAAE;IACrB,OAAOD,KAAK,CAACE,EAAE;EACnB;EACA,MAAMC,KAAK,GAAGJ,KAAK,CAACK,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKR,KAAK,CAACE,YAAY,CAAC;EACtE,IAAI,CAACE,KAAK,EAAE;IACR,OAAOH,KAAK,CAACE,EAAE;EACnB;EACA,MAAMD,YAAY,GAAGE,KAAK,CAACI,OAAO;EAClC,MAAMC,UAAU,GAAGR,KAAK,CAACS,MAAM,CAACR,YAAY,CAAC;EAC7C,IAAI,CAACO,UAAU,EAAE;IACb,OAAOR,KAAK,CAACE,EAAE;EACnB;EAEA,MAAM;IAAEQ,OAAO,GAAG,KAAK;IAAED;EAAO,CAAC,GAAGN,KAAK,CAACQ,gBAAgB,IAAI,CAAC,CAAC;EAChE,IAAI,CAACD,OAAO,IAAI,CAACD,MAAM,IAAIG,KAAK,CAACC,OAAO,CAACJ,MAAM,CAAC,KAAK,KAAK,EAAE;IACxD,OAAOD,UAAU;EACrB;EACA,KAAK,MAAMM,KAAK,IAAIL,MAAM,EAAE;IACxB;IACA,IAAIK,KAAK,CAACA,KAAK,IAAIN,UAAU,EAAE;MAC3B,OAAOM,KAAK,CAACC,KAAK;IACtB;EACJ;EACA,OAAOP,UAAU;AACrB"}

package/utils/getSchemaFromFieldPlugins.d.ts

@@ -0,0 +1,9 @@
+import { CmsModel, CmsFieldTypePlugins, ApiEndpoint } from "../types";
+import { CmsGraphQLSchemaPlugin } from "../plugins";
+interface Params {
+    models: CmsModel[];
+    fieldTypePlugins: CmsFieldTypePlugins;
+    type: ApiEndpoint;
+}
+export declare const createGraphQLSchemaPluginFromFieldPlugins: (params: Params) => CmsGraphQLSchemaPlugin<import("../types").CmsContext>[];
+export {};