@akemona-org/strapi-plugin-content-manager 3.7.0

package/controllers/uid.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { getService } = require('../utils');
+const {
+  validateGenerateUIDInput,
+  validateCheckUIDAvailabilityInput,
+  validateUIDField,
+} = require('./validation');
+
+module.exports = {
+  async generateUID(ctx) {
+    const { contentTypeUID, field, data } = await validateGenerateUIDInput(ctx.request.body);
+
+    await validateUIDField(contentTypeUID, field);
+
+    const uidService = getService('uid');
+
+    ctx.body = {
+      data: await uidService.generateUIDField({ contentTypeUID, field, data }),
+    };
+  },
+
+  async checkUIDAvailability(ctx) {
+    const { contentTypeUID, field, value } = await validateCheckUIDAvailabilityInput(
+      ctx.request.body
+    );
+
+    await validateUIDField(contentTypeUID, field);
+
+    const uidService = getService('uid');
+
+    const isAvailable = await uidService.checkUIDAvailability({ contentTypeUID, field, value });
+
+    ctx.body = {
+      isAvailable,
+      suggestion: !isAvailable
+        ? await uidService.findUniqueUID({ contentTypeUID, field, value })
+        : null,
+    };
+  },
+};

package/controllers/validation/index.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const _ = require('lodash');
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const createModelConfigurationSchema = require('./model-configuration');
+
+const TYPES = ['singleType', 'collectionType'];
+
+const handleError = (error) => {
+  throw strapi.errors.badRequest('ValidationError', formatYupErrors(error));
+};
+
+/**
+ * Validates type kind
+ */
+const validateKind = (kind) => {
+  return yup
+    .string()
+    .oneOf(TYPES)
+    .nullable()
+    .validate(kind)
+    .catch((error) => Promise.reject(formatYupErrors(error)));
+};
+
+const validateBulkDeleteInput = (data = {}) => {
+  return yup
+    .object({
+      ids: yup.array().of(yup.strapiID()).min(1).required(),
+    })
+    .required()
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch(handleError);
+};
+
+const validateGenerateUIDInput = (data) => {
+  return yup
+    .object({
+      contentTypeUID: yup.string().required(),
+      field: yup.string().required(),
+      data: yup.object().required(),
+    })
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch(handleError);
+};
+
+const validateCheckUIDAvailabilityInput = (data) => {
+  return yup
+    .object({
+      contentTypeUID: yup.string().required(),
+      field: yup.string().required(),
+      value: yup.string().matches(new RegExp('^[A-Za-z0-9-_.~]*$')).required(),
+    })
+    .validate(data, {
+      strict: true,
+      abortEarly: false,
+    })
+    .catch(handleError);
+};
+
+const validateUIDField = (contentTypeUID, field) => {
+  const model = strapi.contentTypes[contentTypeUID];
+
+  if (!model) {
+    throw strapi.errors.badRequest('ValidationError', ['ContentType not found']);
+  }
+
+  if (
+    !_.has(model, ['attributes', field]) ||
+    _.get(model, ['attributes', field, 'type']) !== 'uid'
+  ) {
+    throw strapi.errors.badRequest('ValidationError', {
+      field: ['field must be a valid `uid` attribute'],
+    });
+  }
+};
+
+const validatePagination = ({ page, pageSize }) => {
+  const pageNumber = parseInt(page);
+  const pageSizeNumber = parseInt(pageSize);
+
+  if (isNaN(pageNumber) || pageNumber < 1) {
+    throw strapi.errors.badRequest('invalid pageNumber param');
+  }
+  if (isNaN(pageSizeNumber) || pageSizeNumber < 1) {
+    throw strapi.errors.badRequest('invalid pageSize param');
+  }
+};
+
+module.exports = {
+  createModelConfigurationSchema,
+  validateKind,
+  validateBulkDeleteInput,
+  validateGenerateUIDInput,
+  validateCheckUIDAvailabilityInput,
+  validateUIDField,
+  validatePagination,
+};

package/controllers/validation/model-configuration.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { yup } = require('@akemona-org/strapi-utils');
+const {
+  isListable,
+  hasRelationAttribute,
+  hasEditableAttribute,
+} = require('../../services/utils/configuration/attributes');
+/**
+ * Creates the validation schema for content-type configurations
+ */
+module.exports = (schema, opts = {}) =>
+  yup
+    .object()
+    .shape({
+      settings: createSettingsSchema(schema).default(null).nullable(),
+      metadatas: createMetadasSchema(schema).default(null).nullable(),
+      layouts: createLayoutsSchema(schema, opts).default(null).nullable(),
+    })
+    .noUnknown();
+
+const createSettingsSchema = (schema) => {
+  const validAttributes = Object.keys(schema.attributes).filter((key) => isListable(schema, key));
+
+  return yup
+    .object()
+    .shape({
+      bulkable: yup.boolean().required(),
+      filterable: yup.boolean().required(),
+      pageSize: yup.number().integer().min(10).max(100).required(),
+      searchable: yup.boolean().required(),
+      // should be reset when the type changes
+      mainField: yup.string().oneOf(validAttributes.concat('id')).default('id'),
+      // should be reset when the type changes
+      defaultSortBy: yup.string().oneOf(validAttributes.concat('id')).default('id'),
+      defaultSortOrder: yup.string().oneOf(['ASC', 'DESC']).default('ASC'),
+    })
+    .noUnknown();
+};
+
+const createMetadasSchema = (schema) => {
+  return yup.object().shape(
+    Object.keys(schema.attributes).reduce((acc, key) => {
+      acc[key] = yup
+        .object()
+        .shape({
+          edit: yup
+            .object()
+            .shape({
+              label: yup.string(),
+              description: yup.string(),
+              placeholder: yup.string(),
+              editable: yup.boolean(),
+              visible: yup.boolean(),
+              mainField: yup.string(),
+            })
+            .noUnknown()
+            .required(),
+          list: yup
+            .object()
+            .shape({
+              label: yup.string(),
+              searchable: yup.boolean(),
+              sortable: yup.boolean(),
+            })
+            .noUnknown()
+            .required(),
+        })
+        .noUnknown();
+
+      return acc;
+    }, {})
+  );
+};
+
+const createArrayTest = ({ allowUndefined = false } = {}) => ({
+  name: 'isArray',
+  message: '${path} is required and must be an array',
+  test: (val) => (allowUndefined === true && val === undefined ? true : Array.isArray(val)),
+});
+
+const createLayoutsSchema = (schema, opts = {}) => {
+  const validAttributes = Object.keys(schema.attributes).filter((key) => isListable(schema, key));
+
+  const editAttributes = Object.keys(schema.attributes).filter((key) =>
+    hasEditableAttribute(schema, key)
+  );
+
+  const relationAttributes = Object.keys(schema.attributes).filter((key) =>
+    hasRelationAttribute(schema, key)
+  );
+
+  return yup.object().shape({
+    edit: yup
+      .array()
+      .of(
+        yup.array().of(
+          yup
+            .object()
+            .shape({
+              name: yup.string().oneOf(editAttributes).required(),
+              size: yup.number().integer().positive().required(),
+            })
+            .noUnknown()
+        )
+      )
+      .test(createArrayTest(opts)),
+    list: yup.array().of(yup.string().oneOf(validAttributes)).test(createArrayTest(opts)),
+    editRelations: yup
+      .array()
+      .of(yup.string().oneOf(relationAttributes))
+      .test(createArrayTest(opts)),
+  });
+};