@pranaysahith/decap-cms-core 3.9.1

package/src/constants/configSchema.js

@@ -0,0 +1,441 @@
+import AJV from 'ajv';
+import {
+  select,
+  uniqueItemProperties,
+  instanceof as instanceOf,
+  prohibited,
+} from 'ajv-keywords/dist/keywords';
+import ajvErrors from 'ajv-errors';
+import { v4 as uuid } from 'uuid';
+
+import { frontmatterFormats, extensionFormatters } from '../formats/formats';
+import { getWidgets } from '../lib/registry';
+import { I18N_STRUCTURE, I18N_FIELD } from '../lib/i18n';
+
+const localeType = { type: 'string', minLength: 2, maxLength: 10, pattern: '^[a-zA-Z-_]+$' };
+
+const i18n = {
+  type: 'object',
+  properties: {
+    structure: { type: 'string', enum: Object.values(I18N_STRUCTURE) },
+    locales: {
+      type: 'array',
+      minItems: 1,
+      items: localeType,
+      uniqueItems: true,
+    },
+    default_locale: localeType,
+  },
+};
+
+const i18nRoot = {
+  ...i18n,
+  required: ['structure', 'locales'],
+};
+
+const i18nCollection = {
+  oneOf: [{ type: 'boolean' }, i18n],
+};
+
+const i18nField = {
+  oneOf: [{ type: 'boolean' }, { type: 'string', enum: Object.values(I18N_FIELD) }],
+};
+
+/**
+ * Config for fields in both file and folder collections.
+ */
+function fieldsConfig() {
+  const id = uuid();
+  return {
+    $id: `fields_${id}`,
+    type: 'array',
+    minItems: 1,
+    items: {
+      // ------- Each field: -------
+      $id: `field_${id}`,
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        label: { type: 'string' },
+        widget: { type: 'string' },
+        required: { type: 'boolean' },
+        i18n: i18nField,
+        hint: { type: 'string' },
+        pattern: {
+          type: 'array',
+          minItems: 2,
+          items: [{ oneOf: [{ type: 'string' }, { instanceof: 'RegExp' }] }, { type: 'string' }],
+        },
+        field: { $ref: `field_${id}` },
+        fields: { $ref: `fields_${id}` },
+        types: { $ref: `fields_${id}` },
+      },
+      select: { $data: '0/widget' },
+      selectCases: {
+        ...getWidgetSchemas(),
+      },
+      required: ['name'],
+    },
+    uniqueItemProperties: ['name'],
+  };
+}
+
+const viewFilters = {
+  type: 'array',
+  minItems: 1,
+  items: {
+    type: 'object',
+    properties: {
+      label: { type: 'string' },
+      field: { type: 'string' },
+      pattern: {
+        oneOf: [
+          { type: 'boolean' },
+          {
+            type: 'string',
+          },
+        ],
+      },
+    },
+    additionalProperties: false,
+    required: ['label', 'field', 'pattern'],
+  },
+};
+
+const viewGroups = {
+  type: 'array',
+  minItems: 1,
+  items: {
+    type: 'object',
+    properties: {
+      label: { type: 'string' },
+      field: { type: 'string' },
+      pattern: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['label', 'field'],
+  },
+};
+
+/**
+ * The schema had to be wrapped in a function to
+ * fix a circular dependency problem for WebPack,
+ * where the imports get resolved asynchronously.
+ */
+function getConfigSchema() {
+  return {
+    type: 'object',
+    properties: {
+      backend: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', examples: ['test-repo'] },
+          auth_scope: {
+            type: 'string',
+            examples: ['repo', 'public_repo'],
+            enum: ['repo', 'public_repo'],
+          },
+          cms_label_prefix: { type: 'string', minLength: 1 },
+          open_authoring: { type: 'boolean', examples: [true] },
+        },
+        required: ['name'],
+      },
+      local_backend: {
+        oneOf: [
+          { type: 'boolean' },
+          {
+            type: 'object',
+            properties: {
+              url: { type: 'string', examples: ['http://localhost:8081/api/v1'] },
+              allowed_hosts: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+            },
+            additionalProperties: false,
+          },
+        ],
+      },
+      locale: { type: 'string', examples: ['en', 'fr', 'de'] },
+      i18n: i18nRoot,
+      site_url: { type: 'string', examples: ['https://example.com'] },
+      display_url: { type: 'string', examples: ['https://example.com'] },
+      logo_url: { type: 'string', examples: ['https://example.com/images/logo.svg'] }, // Deprecated, replaced by `logo.src`
+      logo: {
+        type: 'object',
+        properties: {
+          src: { type: 'string', examples: ['https://example.com/images/logo.svg'] },
+          show_in_header: { type: 'boolean' },
+        },
+        required: ['src'],
+      },
+      show_preview_links: { type: 'boolean' },
+      media_folder: { type: 'string', examples: ['assets/uploads'] },
+      public_folder: { type: 'string', examples: ['/uploads'] },
+      media_folder_relative: { type: 'boolean' },
+      media_library: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', examples: ['uploadcare'] },
+          config: { type: 'object' },
+        },
+        required: ['name'],
+      },
+      publish_mode: {
+        type: 'string',
+        enum: ['simple', 'editorial_workflow', ''],
+        examples: ['editorial_workflow'],
+      },
+      slug: {
+        type: 'object',
+        properties: {
+          encoding: { type: 'string', enum: ['unicode', 'ascii'] },
+          clean_accents: { type: 'boolean' },
+        },
+      },
+      collections: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          // ------- Each collection: -------
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            label: { type: 'string' },
+            label_singular: { type: 'string' },
+            description: { type: 'string' },
+            folder: { type: 'string' },
+            files: {
+              type: 'array',
+              items: {
+                // ------- Each file: -------
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  label: { type: 'string' },
+                  label_singular: { type: 'string' },
+                  description: { type: 'string' },
+                  file: { type: 'string' },
+                  preview_path: { type: 'string' },
+                  preview_path_date_field: { type: 'string' },
+                  fields: fieldsConfig(),
+                },
+                required: ['name', 'label', 'file', 'fields'],
+              },
+              uniqueItemProperties: ['name'],
+            },
+            identifier_field: { type: 'string' },
+            summary: { type: 'string' },
+            slug: { type: 'string' },
+            path: { type: 'string' },
+            preview_path: { type: 'string' },
+            preview_path_date_field: { type: 'string' },
+            create: { type: 'boolean' },
+            publish: { type: 'boolean' },
+            hide: { type: 'boolean' },
+            editor: {
+              type: 'object',
+              properties: {
+                preview: { type: 'boolean' },
+              },
+            },
+            format: { type: 'string' },
+            extension: { type: 'string' },
+            frontmatter_delimiter: {
+              type: ['string', 'array'],
+              minItems: 2,
+              maxItems: 2,
+              items: {
+                type: 'string',
+              },
+            },
+            fields: fieldsConfig(),
+            sortable_fields: {
+              type: 'array',
+              items: {
+                oneOf: [
+                  { type: 'string' },
+                  {
+                    type: 'object',
+                    properties: {
+                      field: { type: 'string' },
+                      label: { type: 'string' },
+                      default_sort: {
+                        oneOf: [{ type: 'boolean' }, { type: 'string', enum: ['asc', 'desc'] }],
+                      },
+                    },
+                    required: ['field'],
+                    additionalProperties: false,
+                  },
+                ],
+              },
+            },
+            sortableFields: {
+              type: 'array',
+              items: {
+                type: 'string',
+              },
+            },
+            view_filters: viewFilters,
+            view_groups: viewGroups,
+            nested: {
+              type: 'object',
+              properties: {
+                depth: { type: 'number', minimum: 1, maximum: 1000 },
+                subfolders: { type: 'boolean' },
+                summary: { type: 'string' },
+              },
+              required: ['depth'],
+            },
+            meta: {
+              type: 'object',
+              properties: {
+                path: {
+                  type: 'object',
+                  properties: {
+                    label: { type: 'string' },
+                    widget: { type: 'string' },
+                    index_file: { type: 'string' },
+                  },
+                  required: ['label', 'widget'],
+                },
+              },
+              additionalProperties: false,
+              minProperties: 1,
+            },
+            i18n: i18nCollection,
+          },
+          required: ['name', 'label'],
+          oneOf: [{ required: ['files'] }, { required: ['folder', 'fields'] }],
+          not: {
+            required: ['sortable_fields', 'sortableFields'],
+          },
+          if: { required: ['extension'] },
+          then: {
+            // Cannot infer format from extension.
+            if: {
+              properties: {
+                extension: { enum: Object.keys(extensionFormatters) },
+              },
+            },
+            else: { required: ['format'] },
+          },
+          dependencies: {
+            frontmatter_delimiter: {
+              properties: {
+                format: { enum: frontmatterFormats },
+              },
+              required: ['format'],
+            },
+          },
+        },
+        uniqueItemProperties: ['name'],
+      },
+      editor: {
+        type: 'object',
+        properties: {
+          preview: { type: 'boolean' },
+        },
+      },
+    },
+    required: ['backend', 'collections'],
+    anyOf: [{ required: ['media_folder'] }, { required: ['media_library'] }],
+  };
+}
+
+function getWidgetSchemas() {
+  const schemas = getWidgets().map(widget => ({ [widget.name]: widget.schema }));
+  return Object.assign(...schemas);
+}
+
+class ConfigError extends Error {
+  constructor(errors, ...args) {
+    const message = errors
+      .map(({ message, instancePath }) => {
+        const dotPath = instancePath
+          .slice(1)
+          .split('/')
+          .map(seg => (seg.match(/^\d+$/) ? `[${seg}]` : `.${seg}`))
+          .join('')
+          .slice(1);
+        return `${dotPath ? `'${dotPath}'` : 'config'} ${message}`;
+      })
+      .join('\n');
+    super(message, ...args);
+
+    this.errors = errors;
+    this.message = message;
+  }
+
+  toString() {
+    return this.message;
+  }
+}
+
+/**
+ * `validateConfig` is a pure function. It does not mutate
+ * the config that is passed in.
+ */
+export function validateConfig(config) {
+  const ajv = new AJV({ allErrors: true, $data: true, strict: false });
+  uniqueItemProperties(ajv);
+  select(ajv);
+  instanceOf(ajv);
+  prohibited(ajv);
+  ajvErrors(ajv);
+
+  const valid = ajv.validate(getConfigSchema(), config);
+  if (!valid) {
+    const errors = ajv.errors.map(e => {
+      switch (e.keyword) {
+        // TODO: remove after https://github.com/ajv-validator/ajv-keywords/pull/123 is merged
+        case 'uniqueItemProperties': {
+          const path = e.instancePath || '';
+          let newError = e;
+          if (path.endsWith('/fields')) {
+            newError = { ...e, message: 'fields names must be unique' };
+          } else if (path.endsWith('/files')) {
+            newError = { ...e, message: 'files names must be unique' };
+          } else if (path.endsWith('/collections')) {
+            newError = { ...e, message: 'collections names must be unique' };
+          }
+          return newError;
+        }
+        case 'instanceof': {
+          const path = e.instancePath || '';
+          let newError = e;
+          if (/fields\/\d+\/pattern\/\d+/.test(path)) {
+            newError = {
+              ...e,
+              message: 'must be a regular expression',
+            };
+          }
+          return newError;
+        }
+        default:
+          return e;
+      }
+    });
+    console.error('Config Errors', errors);
+    throw new ConfigError(errors);
+  }
+
+  // Custom validation: only one sortable field can have default_sort property
+  if (config.collections) {
+    config.collections.forEach((collection, index) => {
+      if (collection.sortable_fields) {
+        const defaultFields = collection.sortable_fields.filter(
+          field => typeof field === 'object' && field.default_sort !== undefined,
+        );
+        if (defaultFields.length > 1) {
+          const error = {
+            instancePath: `/collections/${index}/sortable_fields`,
+            message: 'only one sortable field can have the default_sort property',
+          };
+          console.error('Config Errors', [error]);
+          throw new ConfigError([error]);
+        }
+      }
+    });
+  }
+}

package/src/constants/fieldInference.tsx

@@ -0,0 +1,78 @@
+import React from 'react';
+
+export const IDENTIFIER_FIELDS = ['title', 'path'] as const;
+
+export const SORTABLE_FIELDS = ['title', 'date', 'author', 'description'] as const;
+
+export const INFERABLE_FIELDS = {
+  title: {
+    type: 'string',
+    secondaryTypes: [],
+    synonyms: ['title', 'name', 'label', 'headline', 'header'],
+    defaultPreview: (value: React.ReactNode) => <h1>{value}</h1>, // eslint-disable-line react/display-name
+    fallbackToFirstField: true,
+    showError: true,
+  },
+  shortTitle: {
+    type: 'string',
+    secondaryTypes: [],
+    synonyms: ['short_title', 'shortTitle', 'short'],
+    defaultPreview: (value: React.ReactNode) => <h2>{value}</h2>, // eslint-disable-line react/display-name
+    fallbackToFirstField: false,
+    showError: false,
+  },
+  author: {
+    type: 'string',
+    secondaryTypes: [],
+    synonyms: ['author', 'name', 'by', 'byline', 'owner'],
+    defaultPreview: (value: React.ReactNode) => <strong>{value}</strong>, // eslint-disable-line react/display-name
+    fallbackToFirstField: false,
+    showError: false,
+  },
+  date: {
+    type: 'datetime',
+    secondaryTypes: ['date'],
+    synonyms: ['date', 'publishDate', 'publish_date'],
+    defaultPreview: (value: React.ReactNode) => value,
+    fallbackToFirstField: false,
+    showError: false,
+  },
+  description: {
+    type: 'string',
+    secondaryTypes: ['text', 'markdown'],
+    synonyms: [
+      'shortDescription',
+      'short_description',
+      'shortdescription',
+      'description',
+      'intro',
+      'introduction',
+      'brief',
+      'content',
+      'biography',
+      'bio',
+      'summary',
+    ],
+    defaultPreview: (value: React.ReactNode) => value,
+    fallbackToFirstField: false,
+    showError: false,
+  },
+  image: {
+    type: 'image',
+    secondaryTypes: [],
+    synonyms: [
+      'image',
+      'thumbnail',
+      'thumb',
+      'picture',
+      'avatar',
+      'photo',
+      'cover',
+      'hero',
+      'logo',
+    ],
+    defaultPreview: (value: React.ReactNode) => value,
+    fallbackToFirstField: false,
+    showError: false,
+  },
+};

package/src/constants/publishModes.ts

@@ -0,0 +1,22 @@
+import { Map, OrderedMap } from 'immutable';
+
+// Create/edit workflow modes
+export const SIMPLE = 'simple';
+export const EDITORIAL_WORKFLOW = 'editorial_workflow';
+
+export const Statues = {
+  DRAFT: 'draft',
+  PENDING_REVIEW: 'pending_review',
+  PENDING_PUBLISH: 'pending_publish',
+};
+
+// Available status
+export const status = OrderedMap(Statues);
+
+export const statusDescriptions = Map({
+  [status.get('DRAFT')]: 'Draft',
+  [status.get('PENDING_REVIEW')]: 'Waiting for Review',
+  [status.get('PENDING_PUBLISH')]: 'Waiting to go live',
+});
+
+export type Status = keyof typeof Statues;

package/src/constants/validationErrorTypes.js

@@ -0,0 +1,6 @@
+export default {
+  PRESENCE: 'PRESENCE',
+  PATTERN: 'PATTERN',
+  RANGE: 'RANGE',
+  CUSTOM: 'CUSTOM',
+};

package/src/formats/__tests__/formats.spec.js

@@ -0,0 +1,87 @@
+import { Map } from 'immutable';
+
+import { extensionFormatters, resolveFormat } from '../formats';
+import { registerCustomFormat } from '../../lib/registry';
+
+describe('custom formats', () => {
+  const testEntry = {
+    collection: 'testCollection',
+    data: { x: 1 },
+    isModification: false,
+    label: 'testLabel',
+    mediaFiles: [],
+    meta: {},
+    newRecord: true,
+    partial: false,
+    path: 'testPath1',
+    raw: 'testRaw',
+    slug: 'testSlug',
+    author: 'testAuthor',
+    updatedOn: 'testUpdatedOn',
+  };
+  it('resolves builtint formats', () => {
+    const collection = Map({
+      name: 'posts',
+    });
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.yml' })).toEqual(
+      extensionFormatters.yml,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.yaml' })).toEqual(
+      extensionFormatters.yml,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.toml' })).toEqual(
+      extensionFormatters.toml,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.json' })).toEqual(
+      extensionFormatters.json,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.md' })).toEqual(
+      extensionFormatters.md,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.markdown' })).toEqual(
+      extensionFormatters.markdown,
+    );
+    expect(resolveFormat(collection, { ...testEntry, path: 'test.html' })).toEqual(
+      extensionFormatters.html,
+    );
+  });
+
+  it('resolves custom format', () => {
+    registerCustomFormat('txt-querystring', 'txt', {
+      fromFile: file => Object.fromEntries(new URLSearchParams(file)),
+      toFile: value => new URLSearchParams(value).toString(),
+    });
+
+    const collection = Map({
+      name: 'posts',
+      format: 'txt-querystring',
+    });
+
+    const formatter = resolveFormat(collection, { ...testEntry, path: 'test.txt' });
+
+    expect(formatter.toFile({ foo: 'bar' })).toEqual('foo=bar');
+    expect(formatter.fromFile('foo=bar')).toEqual({ foo: 'bar' });
+  });
+
+  it('can override existing formatters', () => {
+    // simplified version of a more realistic use case: using a different yaml library like js-yaml
+    // to make netlify-cms play nice with other tools that edit content and spit out yaml
+    registerCustomFormat('bad-yaml', 'yml', {
+      fromFile: file => Object.fromEntries(file.split('\n').map(line => line.split(': '))),
+      toFile: value =>
+        Object.entries(value)
+          .map(([k, v]) => `${k}: ${v}`)
+          .join('\n'),
+    });
+
+    const collection = Map({
+      name: 'posts',
+      format: 'bad-yaml',
+    });
+
+    const formatter = resolveFormat(collection, { ...testEntry, path: 'test.txt' });
+
+    expect(formatter.toFile({ a: 'b', c: 'd' })).toEqual('a: b\nc: d');
+    expect(formatter.fromFile('a: b\nc: d')).toEqual({ a: 'b', c: 'd' });
+  });
+});