@webiny/api-headless-cms 0.0.0-mt-1

package/content/plugins/utils/pluralizedTypeName.d.ts

@@ -0,0 +1 @@
+export declare const pluralizedTypeName: (typeName: string) => any;

package/content/plugins/utils/pluralizedTypeName.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluralizedTypeName = void 0;
+
+var _pluralize = _interopRequireDefault(require("pluralize"));
+
+// This will make it so if the content model name is a single capitalized letter
+// Ex. A, pluralizedTypeName will capitalize the name to As, instead of AS
+const pluralizedTypeName = typeName => {
+  let pluralizedTypeName;
+
+  if (typeName.length === 1) {
+    pluralizedTypeName = `${typeName}s`;
+  } else {
+    pluralizedTypeName = (0, _pluralize.default)(typeName);
+  }
+
+  return pluralizedTypeName;
+};
+
+exports.pluralizedTypeName = pluralizedTypeName;

package/content/plugins/utils/renderFields.d.ts

@@ -0,0 +1,16 @@
+import { CmsFieldTypePlugins, CmsModel, CmsModelFieldDefinition } from "../../../types";
+interface RenderFields {
+    (params: {
+        model: CmsModel;
+        type: string;
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): CmsModelFieldDefinition[];
+}
+export declare const renderFields: RenderFields;
+export declare const renderField: ({ model, type, field, fieldTypePlugins }: {
+    model: any;
+    type: any;
+    field: any;
+    fieldTypePlugins: any;
+}) => any;
+export {};

package/content/plugins/utils/renderFields.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderFields = exports.renderField = void 0;
+
+const renderFields = ({
+  model,
+  type,
+  fieldTypePlugins
+}) => {
+  return model.fields.map(field => renderField({
+    model,
+    type,
+    field,
+    fieldTypePlugins
+  })).filter(Boolean);
+};
+
+exports.renderFields = renderFields;
+
+const renderField = ({
+  model,
+  type,
+  field,
+  fieldTypePlugins
+}) => {
+  const plugin = fieldTypePlugins[field.type];
+
+  if (!plugin) {
+    // Let's not render the field if it does not exist in the field plugins.
+    return;
+  }
+
+  const defs = plugin[type].createTypeField({
+    model,
+    field,
+    fieldTypePlugins
+  });
+
+  if (typeof defs === "string") {
+    return {
+      fields: defs
+    };
+  }
+
+  return defs;
+};
+
+exports.renderField = renderField;

package/content/plugins/utils/renderGetFilterFields.d.ts

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

package/content/plugins/utils/renderGetFilterFields.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderGetFilterFields = void 0;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+const renderGetFilterFields = ({
+  model,
+  fieldTypePlugins
+}) => {
+  const fieldIds = model.fields.filter(f => {
+    // Every time a client updates content model's fields, we check the type of each field. If a field plugin
+    // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
+    // want to be careful when accessing the field plugin here too. It is still possible to have a content model
+    // that contains a field, for which we don't have a plugin registered on the backend. For example, user
+    // could've just removed the plugin from the backend.
+    return (0, _get.default)(fieldTypePlugins, `${f.type}.isSearchable`);
+  }).map(f => f.fieldId);
+  const filters = ["id: ID", "entryId: String"];
+
+  for (let i = 0; i < fieldIds.length; i++) {
+    const field = model.fields.find(item => item.fieldId === fieldIds[i]);
+    const createGetFilters = (0, _get.default)(fieldTypePlugins, `${field.type}.read.createGetFilters`);
+
+    if (typeof createGetFilters === "function") {
+      filters.push(createGetFilters({
+        model,
+        field
+      }));
+    }
+  }
+
+  return filters.filter(Boolean).join("\n");
+};
+
+exports.renderGetFilterFields = renderGetFilterFields;

package/content/plugins/utils/renderInputFields.d.ts

@@ -0,0 +1,14 @@
+import { CmsFieldTypePlugins, CmsModel, CmsModelFieldDefinition } from "../../../types";
+interface RenderInputFields {
+    (params: {
+        model: CmsModel;
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): CmsModelFieldDefinition[];
+}
+export declare const renderInputFields: RenderInputFields;
+export declare const renderInputField: ({ model, field, fieldTypePlugins }: {
+    model: any;
+    field: any;
+    fieldTypePlugins: any;
+}) => CmsModelFieldDefinition;
+export {};

package/content/plugins/utils/renderInputFields.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderInputFields = exports.renderInputField = void 0;
+
+const renderInputFields = ({
+  model,
+  fieldTypePlugins
+}) => {
+  return model.fields.map(field => renderInputField({
+    model,
+    field,
+    fieldTypePlugins
+  })).filter(Boolean);
+};
+
+exports.renderInputFields = renderInputFields;
+
+const renderInputField = ({
+  model,
+  field,
+  fieldTypePlugins
+}) => {
+  // Every time a client updates content model's fields, we check the type of each field. If a field plugin
+  // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
+  // want to be careful when accessing the field plugin here too. It is still possible to have a content model
+  // that contains a field, for which we don't have a plugin registered on the backend. For example, user
+  // could've just removed the plugin from the backend.
+  const plugin = fieldTypePlugins[field.type];
+
+  if (!plugin) {
+    // Let's not render the field if it does not exist in the field plugins.
+    return;
+  }
+
+  const def = plugin.manage.createInputField({
+    model,
+    field,
+    fieldTypePlugins
+  });
+
+  if (typeof def === "string") {
+    return {
+      fields: def
+    };
+  }
+
+  return def;
+};
+
+exports.renderInputField = renderInputField;

package/content/plugins/utils/renderListFilterFields.d.ts

@@ -0,0 +1,10 @@
+import { CmsFieldTypePlugins, CmsModel } from "../../../types";
+interface RenderListFilterFields {
+    (params: {
+        model: CmsModel;
+        type: "read" | "manage";
+        fieldTypePlugins: CmsFieldTypePlugins;
+    }): string;
+}
+export declare const renderListFilterFields: RenderListFilterFields;
+export {};

package/content/plugins/utils/renderListFilterFields.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderListFilterFields = void 0;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+const renderListFilterFields = ({
+  model,
+  type,
+  fieldTypePlugins
+}) => {
+  const fields = [["id: ID", "id_not: ID", "id_in: [ID!]", "id_not_in: [ID!]", "entryId: String", "entryId_not: String", "entryId_in: [String!]", "entryId_not_in: [String!]", "createdOn: DateTime", "createdOn_gt: DateTime", "createdOn_gte: DateTime", "createdOn_lt: DateTime", "createdOn_lte: DateTime", "createdOn_between: [DateTime!]", "createdOn_not_between: [DateTime!]", "savedOn: DateTime", "savedOn_gt: DateTime", "savedOn_gte: DateTime", "savedOn_lt: DateTime", "savedOn_lte: DateTime", "savedOn_between: [DateTime!]", "savedOn_not_between: [DateTime!]", "createdBy: String", "createdBy_not: String", "createdBy_in: [String!]", "createdBy_not_in: [String!]", "ownedBy: String", "ownedBy_not: String", "ownedBy_in: [String!]", "ownedBy_not_in: [String!]"].join("\n")];
+
+  for (let i = 0; i < model.fields.length; i++) {
+    const field = model.fields[i]; // Every time a client updates content model's fields, we check the type of each field. If a field plugin
+    // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
+    // want to be careful when accessing the field plugin here too. It is still possible to have a content model
+    // that contains a field, for which we don't have a plugin registered on the backend. For example, user
+    // could've just removed the plugin from the backend.
+
+    const createListFilters = (0, _get.default)(fieldTypePlugins, `${field.type}.${type}.createListFilters`);
+
+    if (typeof createListFilters === "function") {
+      fields.push(createListFilters({
+        model,
+        field
+      }));
+    }
+  }
+
+  return fields.filter(Boolean).join("\n");
+};
+
+exports.renderListFilterFields = renderListFilterFields;

package/content/plugins/utils/renderSortEnum.d.ts

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

package/content/plugins/utils/renderSortEnum.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderSortEnum = void 0;
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+const renderSortEnum = ({
+  model,
+  fieldTypePlugins
+}) => {
+  const sorters = [`id_ASC`, `id_DESC`, "savedOn_ASC", "savedOn_DESC", "createdOn_ASC", "createdOn_DESC"];
+  const fieldIds = model.fields.filter(f => {
+    // Every time a client updates content model's fields, we check the type of each field. If a field plugin
+    // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
+    // want to be careful when accessing the field plugin here too. It is still possible to have a content model
+    // that contains a field, for which we don't have a plugin registered on the backend. For example, user
+    // could've just removed the plugin from the backend.
+    return (0, _get.default)(fieldTypePlugins, `${f.type}.isSortable`);
+  }).map(f => f.fieldId);
+  fieldIds.forEach(fieldId => {
+    sorters.push(`${fieldId}_ASC`);
+    sorters.push(`${fieldId}_DESC`);
+  });
+  return sorters.join("\n");
+};
+
+exports.renderSortEnum = renderSortEnum;

package/content/plugins/validators/dateGte.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const _default: () => CmsModelFieldValidatorPlugin;
+export default _default;

package/content/plugins/validators/dateGte.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+var _default = () => ({
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-date-gte",
+  validator: {
+    name: "dateGte",
+
+    async validate({
+      value,
+      validator
+    }) {
+      const {
+        value: gteValue,
+        type
+      } = validator.settings;
+
+      if (typeof gteValue === "undefined") {
+        return true;
+      } else if (type === "time") {
+        return _validation.validation.validate(value, `timeGte:${gteValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return _validation.validation.validate(value, `dateGte:${gteValue}`).then(v => v === true).catch(() => false);
+    }
+
+  }
+});
+
+exports.default = _default;

package/content/plugins/validators/dateLte.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const _default: () => CmsModelFieldValidatorPlugin;
+export default _default;

package/content/plugins/validators/dateLte.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+var _default = () => ({
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-date-lte",
+  validator: {
+    name: "dateLte",
+
+    async validate({
+      value,
+      validator
+    }) {
+      const {
+        value: lteValue,
+        type
+      } = validator.settings;
+
+      if (typeof lteValue === "undefined") {
+        return true;
+      } else if (type === "time") {
+        return _validation.validation.validate(value, `timeLte:${lteValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return _validation.validation.validate(value, `dateLte:${lteValue}`).then(v => v === true).catch(() => false);
+    }
+
+  }
+});
+
+exports.default = _default;

package/content/plugins/validators/gte.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;

package/content/plugins/validators/gte.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+const plugin = {
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-gte",
+  validator: {
+    name: "gte",
+
+    validate({
+      value,
+      validator
+    }) {
+      const gteValue = validator.settings.value;
+
+      if (typeof gteValue !== "undefined") {
+        return _validation.validation.validate(value, `gte:${gteValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return Promise.resolve(true);
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/validators/in.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;

package/content/plugins/validators/in.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+const plugin = {
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-in",
+  validator: {
+    name: "in",
+
+    validate({
+      value,
+      validator
+    }) {
+      const values = validator.settings.values;
+
+      if (Array.isArray(values)) {
+        return _validation.validation.validate(value, `in:${values.join(":")}`).then(v => v === true).catch(() => false);
+      }
+
+      return Promise.resolve(true);
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/validators/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (import("../../../types").CmsModelFieldValidatorPlugin | import("../../../types").CmsModelFieldPatternValidatorPlugin[])[];
+export default _default;

package/content/plugins/validators/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _gte = _interopRequireDefault(require("./gte"));
+
+var _in = _interopRequireDefault(require("./in"));
+
+var _lte = _interopRequireDefault(require("./lte"));
+
+var _maxLength = _interopRequireDefault(require("./maxLength"));
+
+var _minLength = _interopRequireDefault(require("./minLength"));
+
+var _pattern = _interopRequireDefault(require("./pattern"));
+
+var _required = _interopRequireDefault(require("./required"));
+
+var _patternPlugins = _interopRequireDefault(require("./patternPlugins"));
+
+var _dateLte = _interopRequireDefault(require("./dateLte"));
+
+var _dateGte = _interopRequireDefault(require("./dateGte"));
+
+var _timeLte = _interopRequireDefault(require("./timeLte"));
+
+var _timeGte = _interopRequireDefault(require("./timeGte"));
+
+var _default = () => [_gte.default, _in.default, _lte.default, _pattern.default, _required.default, _minLength.default, _maxLength.default, _patternPlugins.default, (0, _dateLte.default)(), (0, _dateGte.default)(), (0, _timeLte.default)(), (0, _timeGte.default)()];
+
+exports.default = _default;

package/content/plugins/validators/lte.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;

package/content/plugins/validators/lte.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+const plugin = {
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-lte",
+  validator: {
+    name: "lte",
+
+    validate({
+      value,
+      validator
+    }) {
+      const lteValue = validator.settings.value;
+
+      if (typeof lteValue !== "undefined") {
+        return _validation.validation.validate(value, `lte:${lteValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return Promise.resolve(true);
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/validators/maxLength.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;

package/content/plugins/validators/maxLength.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+const plugin = {
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-max-length",
+  validator: {
+    name: "maxLength",
+
+    validate({
+      value,
+      validator
+    }) {
+      const maxLengthValue = validator.settings.value;
+
+      if (typeof maxLengthValue !== "undefined") {
+        return _validation.validation.validate(value, `maxLength:${maxLengthValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return Promise.resolve(true);
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/validators/minLength.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;

package/content/plugins/validators/minLength.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _validation = require("@webiny/validation");
+
+const plugin = {
+  type: "cms-model-field-validator",
+  name: "cms-model-field-validator-min-length",
+  validator: {
+    name: "minLength",
+
+    validate({
+      value,
+      validator
+    }) {
+      const minLengthValue = validator.settings.value;
+
+      if (typeof minLengthValue !== "undefined") {
+        return _validation.validation.validate(value, `minLength:${minLengthValue}`).then(v => v === true).catch(() => false);
+      }
+
+      return Promise.resolve(true);
+    }
+
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/content/plugins/validators/pattern.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldValidatorPlugin } from "../../../types";
+declare const plugin: CmsModelFieldValidatorPlugin;
+export default plugin;