@webiny/api-headless-cms 0.0.0-ee-vpcs.549378cf03

package/utils/converters/valueKeyStorageConverter.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createValueKeyToStorageConverter = exports.createValueKeyFromStorageConverter = exports.attachCmsModelFieldConverters = 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.
+   */
+
+
+  if (process.env.NODE_ENV === "test" || isBetaOrNext(model) === true) {
+    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 attachCmsModelFieldConverters = params => {
+  const {
+    model,
+    plugins
+  } = params;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+    convertValueKeyToStorage: createValueKeyToStorageConverter({
+      model,
+      plugins
+    }),
+    convertValueKeyFromStorage: createValueKeyFromStorageConverter({
+      model,
+      plugins
+    })
+  });
+};
+
+exports.attachCmsModelFieldConverters = attachCmsModelFieldConverters;

package/utils/converters/valueKeyStorageConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["featureVersion","semver","coerce","isBetaOrNext","model","webinyVersion","match","isFeatureEnabled","process","env","NODE_ENV","modelVersion","console","log","modelId","compare","createValueKeyToStorageConverter","params","plugins","values","converters","ConverterCollection","fields","result","convertToStorage","createValueKeyFromStorageConverter","convertFromStorage","attachCmsModelFieldConverters","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    if (process.env.NODE_ENV === \"test\" || isBetaOrNext(model) === true) {\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\ninterface AttachConvertersParams {\n    plugins: PluginsContainer;\n    model: CmsModel;\n}\nexport const attachCmsModelFieldConverters = (\n    params: AttachConvertersParams\n): StorageOperationsCmsModel => {\n    const { model, plugins } = params;\n    return {\n        ...model,\n        convertValueKeyToStorage: createValueKeyToStorageConverter({\n            model,\n            plugins\n        }),\n        convertValueKeyFromStorage: createValueKeyFromStorageConverter({\n            model,\n            plugins\n        })\n    };\n};\n"],"mappings":";;;;;;;;;;;AACA;;AAMA;;AAEA,MAAMA,cAAc,GAAGC,eAAA,CAAOC,MAAP,CAAc,QAAd,CAAvB;;AAEA,MAAMC,YAAY,GAAIC,KAAD,IAA8B;EAC/C,IAAI,CAACA,KAAK,CAACC,aAAX,EAA0B;IACtB,OAAO,KAAP;EACH;;EACD,OAAOD,KAAK,CAACC,aAAN,CAAoBC,KAApB,CAA0B,WAA1B,MAA2C,IAAlD;AACH,CALD;;AAOA,MAAMC,gBAAgB,GAAIH,KAAD,IAA8B;EACnD;AACJ;AACA;AACA;EACI,IAAIA,KAAK,CAACC,aAAN,KAAwB,SAA5B,EAAuC;IACnC,OAAO,KAAP;EACH;EACD;AACJ;AACA;;;EACI,IAAIG,OAAO,CAACC,GAAR,CAAYC,QAAZ,KAAyB,MAAzB,IAAmCP,YAAY,CAACC,KAAD,CAAZ,KAAwB,IAA/D,EAAqE;IACjE,OAAO,IAAP;EACH;EACD;AACJ;AACA;;;EACI,IAAI,CAACA,KAAK,CAACC,aAAX,EAA0B;IACtB,OAAO,KAAP;EACH;EACD;AACJ;AACA;AACA;AACA;;;EACI,MAAMM,YAAY,GAAGV,eAAA,CAAOC,MAAP,CAAcE,KAAK,CAACC,aAApB,CAArB;;EACA,IAAI,CAACM,YAAL,EAAmB;IACfC,OAAO,CAACC,GAAR,CAAa,mBAAkBT,KAAK,CAACU,OAAQ,2CAA7C;IACA,OAAO,IAAP;EACH,CAHD,MAGO,IAAIb,eAAA,CAAOc,OAAP,CAAeJ,YAAf,EAA6BX,cAA7B,MAAiD,CAAC,CAAtD,EAAyD;IAC5D,OAAO,KAAP;EACH;;EACD,OAAO,IAAP;AACH,CAjCD;;AAmDO,MAAMgB,gCAAgC,GAAIC,MAAD,IAA+C;EAC3F,MAAM;IAAEC,OAAF;IAAWd;EAAX,IAAqBa,MAA3B;;EAEA,IAAIV,gBAAgB,CAACH,KAAD,CAAhB,KAA4B,KAAhC,EAAuC;IACnC,OAAO,CAAC;MAAEe;IAAF,CAAD,KAAkD;MACrD,OAAOA,MAAM,IAAI,EAAjB;IACH,CAFD;EAGH;;EAED,MAAMC,UAAU,GAAG,IAAIC,wCAAJ,CAAwB;IACvCH;EADuC,CAAxB,CAAnB;EAIA,OAAO,CAAC;IAAEI,MAAF;IAAUH;EAAV,CAAD,KAA0D;IAC7D,MAAMI,MAAM,GAAGH,UAAU,CAACI,gBAAX,CAA4B;MACvCF,MAAM,EAAEA,MAAM,IAAIlB,KAAK,CAACkB,MADe;MAEvCH;IAFuC,CAA5B,CAAf;IAIA,OAAOI,MAAM,IAAI,EAAjB;EACH,CAND;AAOH,CApBM;;;;AAsBA,MAAME,kCAAkC,GAAIR,MAAD,IAA+C;EAC7F,MAAM;IAAEC,OAAF;IAAWd;EAAX,IAAqBa,MAA3B;;EAEA,IAAIV,gBAAgB,CAACH,KAAD,CAAhB,KAA4B,KAAhC,EAAuC;IACnC,OAAO,CAAC;MAAEe;IAAF,CAAD,KAAkD;MACrD,OAAOA,MAAM,IAAI,EAAjB;IACH,CAFD;EAGH;;EAED,MAAMC,UAAU,GAAG,IAAIC,wCAAJ,CAAwB;IACvCH;EADuC,CAAxB,CAAnB;EAIA,OAAO,CAAC;IAAEI,MAAF;IAAUH;EAAV,CAAD,KAA0D;IAC7D,MAAMI,MAAM,GAAGH,UAAU,CAACM,kBAAX,CAA8B;MACzCJ,MAAM,EAAEA,MAAM,IAAIlB,KAAK,CAACkB,MADiB;MAEzCH;IAFyC,CAA9B,CAAf;IAIA,OAAOI,MAAM,IAAI,EAAjB;EACH,CAND;AAOH,CApBM;;;;AA0BA,MAAMI,6BAA6B,GACtCV,MADyC,IAEb;EAC5B,MAAM;IAAEb,KAAF;IAASc;EAAT,IAAqBD,MAA3B;EACA,mEACOb,KADP;IAEIwB,wBAAwB,EAAEZ,gCAAgC,CAAC;MACvDZ,KADuD;MAEvDc;IAFuD,CAAD,CAF9D;IAMIW,0BAA0B,EAAEJ,kCAAkC,CAAC;MAC3DrB,KAD2D;MAE3Dc;IAF2D,CAAD;EANlE;AAWH,CAfM"}

package/utils/createTypeFromFields.d.ts

@@ -0,0 +1,15 @@
+import { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField } from "../types";
+interface TypeFromFieldParams {
+    typeOfType: "type" | "input";
+    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,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeFromFields = void 0;
+
+var _createTypeName = require("./createTypeName");
+
+var _renderFields = require("./renderFields");
+
+var _renderInputFields = require("./renderInputFields");
+
+const createTypeFromFields = params => {
+  const {
+    typeOfType,
+    model,
+    type,
+    typeNamePrefix,
+    fields,
+    fieldTypePlugins
+  } = params;
+  const typeSuffix = typeOfType === "input" ? "Input" : "";
+  const mTypeName = (0, _createTypeName.createTypeName)(model.modelId);
+  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 f of fields) {
+    const result = typeOfType === "type" ? (0, _renderFields.renderField)({
+      field: f,
+      type,
+      model,
+      fieldTypePlugins
+    }) : (0, _renderInputFields.renderInputField)({
+      field: f,
+      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","type","typeNamePrefix","fields","fieldTypePlugins","typeSuffix","mTypeName","createTypeName","modelId","typeFields","nestedTypes","replace","RegExp","f","result","renderField","field","renderInputField","typeDefs","push","fieldType","join"],"sources":["createTypeFromFields.ts"],"sourcesContent":["import { createTypeName } from \"~/utils/createTypeName\";\nimport { renderField } from \"~/utils/renderFields\";\nimport { renderInputField } from \"~/utils/renderInputFields\";\nimport { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField } from \"~/types\";\n\ninterface TypeFromFieldParams {\n    typeOfType: \"type\" | \"input\";\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, type, typeNamePrefix, fields, fieldTypePlugins } = params;\n    const typeSuffix = typeOfType === \"input\" ? \"Input\" : \"\";\n    const mTypeName = createTypeName(model.modelId);\n\n    const typeFields = [];\n    const nestedTypes = [];\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 f of fields) {\n        const result =\n            typeOfType === \"type\"\n                ? renderField({ field: f, type, model, fieldTypePlugins })\n                : renderInputField({ field: f, 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;;AACA;;AAiBO,MAAMA,oBAAoB,GAAIC,MAAD,IAA+D;EAC/F,MAAM;IAAEC,UAAF;IAAcC,KAAd;IAAqBC,IAArB;IAA2BC,cAA3B;IAA2CC,MAA3C;IAAmDC;EAAnD,IAAwEN,MAA9E;EACA,MAAMO,UAAU,GAAGN,UAAU,KAAK,OAAf,GAAyB,OAAzB,GAAmC,EAAtD;EACA,MAAMO,SAAS,GAAG,IAAAC,8BAAA,EAAeP,KAAK,CAACQ,OAArB,CAAlB;EAEA,MAAMC,UAAU,GAAG,EAAnB;EACA,MAAMC,WAAW,GAAG,EAApB,CAN+F,CAQ/F;EACA;EACA;EACA;EACA;;EACA,MAAMC,OAAO,GAAG,IAAIC,MAAJ,CAAY,GAAEN,SAAU,GAAxB,EAA4B,GAA5B,CAAhB;;EAEA,KAAK,MAAMO,CAAX,IAAgBV,MAAhB,EAAwB;IACpB,MAAMW,MAAM,GACRf,UAAU,KAAK,MAAf,GACM,IAAAgB,yBAAA,EAAY;MAAEC,KAAK,EAAEH,CAAT;MAAYZ,IAAZ;MAAkBD,KAAlB;MAAyBI;IAAzB,CAAZ,CADN,GAEM,IAAAa,mCAAA,EAAiB;MAAED,KAAK,EAAEH,CAAT;MAAYb,KAAZ;MAAmBI;IAAnB,CAAjB,CAHV;;IAKA,IAAI,CAACU,MAAL,EAAa;MACT;IACH;;IAED,MAAM;MAAEX,MAAF;MAAUe;IAAV,IAAuBJ,MAA7B;IAEAL,UAAU,CAACU,IAAX,CAAgBhB,MAAM,CAACQ,OAAP,CAAeA,OAAf,EAAyB,GAAET,cAAe,GAA1C,CAAhB;;IACA,IAAIgB,QAAJ,EAAc;MACVR,WAAW,CAACS,IAAZ,CAAiBD,QAAQ,CAACP,OAAT,CAAiBA,OAAjB,EAA2B,GAAET,cAAe,GAA5C,CAAjB;IACH;EACJ;;EAED,OAAO;IACHkB,SAAS,EAAG,GAAElB,cAAe,GAAEG,UAAW,EADvC;IAEHa,QAAQ;IAAE;IAAe;AACjC,cAAcR,WAAW,CAACW,IAAZ,CAAiB,IAAjB,CAAuB;AACrC;AACA,cAActB,UAAW,IAAGG,cAAe,GAAEG,UAAW;AACxD,kBAAkBI,UAAU,CAACY,IAAX,CAAgB,IAAhB,CAAsB;AACxC;AACA;EARW,CAAP;AAUH,CA3CM"}

package/utils/createTypeName.d.ts

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

package/utils/createTypeName.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeName = exports.createReadTypeName = exports.createManageTypeName = 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;
+
+const createReadTypeName = baseTypeName => {
+  return createTypeName(baseTypeName);
+};
+
+exports.createReadTypeName = createReadTypeName;
+
+const createManageTypeName = baseTypeName => {
+  return createTypeName(baseTypeName);
+};
+
+exports.createManageTypeName = createManageTypeName;

package/utils/createTypeName.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createTypeName","modelId","upperFirst","camelCase","createReadTypeName","baseTypeName","createManageTypeName"],"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\nexport const createReadTypeName = (baseTypeName: string): string => {\n    return createTypeName(baseTypeName);\n};\n\nexport const createManageTypeName = (baseTypeName: string): string => {\n    return createTypeName(baseTypeName);\n};\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AAEO,MAAMA,cAAc,GAAIC,OAAD,IAA6B;EACvD,OAAO,IAAAC,mBAAA,EAAW,IAAAC,kBAAA,EAAUF,OAAV,CAAX,CAAP;AACH,CAFM;;;;AAIA,MAAMG,kBAAkB,GAAIC,YAAD,IAAkC;EAChE,OAAOL,cAAc,CAACK,YAAD,CAArB;AACH,CAFM;;;;AAIA,MAAMC,oBAAoB,GAAID,YAAD,IAAkC;EAClE,OAAOL,cAAc,CAACK,YAAD,CAArB;AACH,CAFM"}

package/utils/entryStorage.d.ts

@@ -0,0 +1,17 @@
+import { CmsEntry, CmsModel, CmsModelField, CmsContext } from "../types";
+/**
+ * A function that is used in crud to transform entry into the storage type.
+ */
+export declare const entryToStorageTransform: (context: CmsContext, model: CmsModel, entry: CmsEntry) => Promise<CmsEntry>;
+/**
+ * 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) => Promise<CmsEntry>;
+interface EntryFieldFromStorageTransformParams {
+    context: CmsContext;
+    model: CmsModel;
+    field: CmsModelField;
+    value: any;
+}
+export declare const entryFieldFromStorageTransform: <T = any>(params: EntryFieldFromStorageTransformParams) => Promise<T>;
+export {};

package/utils/entryStorage.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entryToStorageTransform = exports.entryFromStorageTransform = exports.entryFieldFromStorageTransform = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+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
+  .reverse().reduce((collection, plugin) => {
+    /**
+     * Check if it's a default plugin and set it - always override the previous one.
+     */
+    if (plugin.fieldType === "*") {
+      defaultStoragePlugin = plugin;
+      return collection;
+    }
+    /**
+     * We will just set the plugin for given type.
+     * The last one will override existing one - so users can override our default ones.
+     */
+
+
+    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 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 "${baseType}"`);
+    }
+
+    transformedValues[field.fieldId] = await plugin[operation]({
+      plugins: context.plugins,
+      model,
+      field,
+      value: entry.values[field.fieldId],
+      getStoragePlugin
+    });
+  }
+
+  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) => {
+  return entryStorageTransform(context, model, "fromStorage", entry);
+};
+
+exports.entryFromStorageTransform = entryFromStorageTransform;
+
+/*
+ * A function that is used to transform a single field from storage
+ */
+const entryFieldFromStorageTransform = async params => {
+  const {
+    context,
+    model,
+    field,
+    value
+  } = params;
+  const getStoragePlugin = getStoragePluginFactory(context);
+  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 "${baseType}"`);
+  }
+
+  return plugin.fromStorage({
+    plugins: context.plugins,
+    model,
+    field,
+    value,
+    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,23 @@
+"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,KADuB,EAEvBC,SAFuB,KAGR;EACf,MAAMC,aAAa,GAAG,EAAtB;;EAEA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,KAAK,CAACI,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;IACnC,MAAME,IAAI,GAAGL,KAAK,CAACG,CAAD,CAAlB;IACA,MAAMG,KAAK,GAAG,MAAML,SAAS,CAACI,IAAD,CAA7B;;IACA,IAAIC,KAAJ,EAAW;MACPJ,aAAa,CAACK,IAAd,CAAmBF,IAAnB;IACH;EACJ;;EAED,OAAOH,aAAP;AACH,CAfM"}

package/utils/filterModelFields.d.ts

@@ -0,0 +1,16 @@
+/**
+ * We are leaving this file because isDeleted might come back later
+ */
+import { ApiEndpoint, CmsModel } from "../types";
+/**
+ * Filters deleted fields from all given models.
+ */
+interface FilterModelsDeletedFieldsCallableParams {
+    models: CmsModel[];
+    type: ApiEndpoint;
+}
+interface FilterModelsDeletedFieldsCallable {
+    (params: FilterModelsDeletedFieldsCallableParams): CmsModel[];
+}
+export declare const filterModelsDeletedFields: FilterModelsDeletedFieldsCallable;
+export {};

package/utils/filterModelFields.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterModelsDeletedFields = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+/**
+ * We are leaving this file because isDeleted might come back later
+ */
+// @ts-nocheck
+
+/**
+ * Filters deleted fields from the list of fields.
+ *
+ * Used to recursively delete fields - object field.
+ */
+const filterDeletedFields = params => {
+  return params.fields.reduce((output, field) => {
+    var _field$settings;
+
+    if (!!field.isDeleted) {
+      return output;
+    } else if ((_field$settings = field.settings) !== null && _field$settings !== void 0 && _field$settings.fields) {
+      const fields = filterDeletedFields({
+        fields: field.settings.fields
+      });
+      output.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, field), {}, {
+        settings: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, field.settings), {}, {
+          fields
+        })
+      }));
+      return output;
+    }
+
+    output.push(field);
+    return output;
+  }, []);
+};
+/**
+ * Filters deleted fields from given model.
+ */
+
+
+const filterModelDeletedFields = ({
+  model
+}) => {
+  const fields = filterDeletedFields(model);
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+    fields
+  });
+};
+/**
+ * Filters deleted fields from all given models.
+ */
+
+
+const filterModelsDeletedFields = ({
+  models,
+  type
+}) => {
+  if (type === "manage") {
+    return models;
+  }
+
+  return models.map(model => {
+    return filterModelDeletedFields({
+      model
+    });
+  });
+};
+
+exports.filterModelsDeletedFields = filterModelsDeletedFields;

package/utils/filterModelFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["filterDeletedFields","params","fields","reduce","output","field","isDeleted","settings","push","filterModelDeletedFields","model","filterModelsDeletedFields","models","type","map"],"sources":["filterModelFields.ts"],"sourcesContent":["/**\n * We are leaving this file because isDeleted might come back later\n */\n// @ts-nocheck\nimport { ApiEndpoint, CmsModel, CmsModelField } from \"~/types\";\n\n/**\n * Filters deleted fields from the list of fields.\n *\n * Used to recursively delete fields - object field.\n */\ninterface FilterModelFieldsCallableParams {\n    fields: CmsModelField[];\n}\ninterface FilterModelFieldsCallable {\n    (params: FilterModelFieldsCallableParams): CmsModelField[];\n}\n\nconst filterDeletedFields: FilterModelFieldsCallable = params => {\n    return params.fields.reduce<CmsModelField[]>((output, field) => {\n        if (!!field.isDeleted) {\n            return output;\n        } else if (field.settings?.fields) {\n            const fields = filterDeletedFields({\n                fields: field.settings.fields\n            });\n\n            output.push({\n                ...field,\n                settings: {\n                    ...field.settings,\n                    fields\n                }\n            });\n            return output;\n        }\n\n        output.push(field);\n\n        return output;\n    }, []);\n};\n\n/**\n * Filters deleted fields from given model.\n */\ninterface FilterModelDeletedFieldsCallableParams {\n    model: CmsModel;\n}\ninterface FilterModelDeletedFieldsCallable {\n    (params: FilterModelDeletedFieldsCallableParams): CmsModel;\n}\nconst filterModelDeletedFields: FilterModelDeletedFieldsCallable = ({ model }) => {\n    const fields = filterDeletedFields(model);\n    return {\n        ...model,\n        fields\n    };\n};\n\n/**\n * Filters deleted fields from all given models.\n */\ninterface FilterModelsDeletedFieldsCallableParams {\n    models: CmsModel[];\n    type: ApiEndpoint;\n}\ninterface FilterModelsDeletedFieldsCallable {\n    (params: FilterModelsDeletedFieldsCallableParams): CmsModel[];\n}\nexport const filterModelsDeletedFields: FilterModelsDeletedFieldsCallable = ({ models, type }) => {\n    if (type === \"manage\") {\n        return models;\n    }\n    return models.map(model => {\n        return filterModelDeletedFields({\n            model\n        });\n    });\n};\n"],"mappings":";;;;;;;;;;;AAAA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AAQA,MAAMA,mBAA8C,GAAGC,MAAM,IAAI;EAC7D,OAAOA,MAAM,CAACC,MAAP,CAAcC,MAAd,CAAsC,CAACC,MAAD,EAASC,KAAT,KAAmB;IAAA;;IAC5D,IAAI,CAAC,CAACA,KAAK,CAACC,SAAZ,EAAuB;MACnB,OAAOF,MAAP;IACH,CAFD,MAEO,uBAAIC,KAAK,CAACE,QAAV,4CAAI,gBAAgBL,MAApB,EAA4B;MAC/B,MAAMA,MAAM,GAAGF,mBAAmB,CAAC;QAC/BE,MAAM,EAAEG,KAAK,CAACE,QAAN,CAAeL;MADQ,CAAD,CAAlC;MAIAE,MAAM,CAACI,IAAP,6DACOH,KADP;QAEIE,QAAQ,8DACDF,KAAK,CAACE,QADL;UAEJL;QAFI;MAFZ;MAOA,OAAOE,MAAP;IACH;;IAEDA,MAAM,CAACI,IAAP,CAAYH,KAAZ;IAEA,OAAOD,MAAP;EACH,CArBM,EAqBJ,EArBI,CAAP;AAsBH,CAvBD;AAyBA;AACA;AACA;;;AAOA,MAAMK,wBAA0D,GAAG,CAAC;EAAEC;AAAF,CAAD,KAAe;EAC9E,MAAMR,MAAM,GAAGF,mBAAmB,CAACU,KAAD,CAAlC;EACA,mEACOA,KADP;IAEIR;EAFJ;AAIH,CAND;AAQA;AACA;AACA;;;AAQO,MAAMS,yBAA4D,GAAG,CAAC;EAAEC,MAAF;EAAUC;AAAV,CAAD,KAAsB;EAC9F,IAAIA,IAAI,KAAK,QAAb,EAAuB;IACnB,OAAOD,MAAP;EACH;;EACD,OAAOA,MAAM,CAACE,GAAP,CAAWJ,KAAK,IAAI;IACvB,OAAOD,wBAAwB,CAAC;MAC5BC;IAD4B,CAAD,CAA/B;EAGH,CAJM,CAAP;AAKH,CATM"}

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,12 @@
+"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,KAAD,IAA4C;EACxE,OAAOA,KAAK,CAACC,IAAN,CAAWC,KAAX,CAAiB,GAAjB,EAAsB,CAAtB,CAAP;AACH,CAFM"}

package/utils/getEntryTitle.d.ts

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