@pranaysahith/decap-cms-core 3.9.1

package/src/formats/frontmatter.ts

@@ -0,0 +1,150 @@
+import matter from 'gray-matter';
+
+import tomlFormatter from './toml';
+import yamlFormatter from './yaml';
+import jsonFormatter from './json';
+
+const Languages = {
+  YAML: 'yaml',
+  TOML: 'toml',
+  JSON: 'json',
+} as const;
+
+type Language = (typeof Languages)[keyof typeof Languages];
+
+export type Delimiter = string | [string, string];
+type Format = { language: Language; delimiters: Delimiter };
+
+const parsers = {
+  toml: {
+    parse: (input: string) => tomlFormatter.fromFile(input),
+    stringify: (metadata: object, opts?: { sortedKeys?: string[] }) => {
+      const { sortedKeys } = opts || {};
+      return tomlFormatter.toFile(metadata, sortedKeys);
+    },
+  },
+  json: {
+    parse: (input: string) => {
+      let JSONinput = input.trim();
+      // Fix JSON if leading and trailing brackets were trimmed.
+      if (JSONinput.slice(0, 1) !== '{') {
+        JSONinput = '{' + JSONinput + '}';
+      }
+      return jsonFormatter.fromFile(JSONinput);
+    },
+    stringify: (metadata: object) => {
+      let JSONoutput = jsonFormatter.toFile(metadata).trim();
+      // Trim leading and trailing brackets.
+      if (JSONoutput.slice(0, 1) === '{' && JSONoutput.slice(-1) === '}') {
+        JSONoutput = JSONoutput.slice(1, -1);
+      }
+      return JSONoutput;
+    },
+  },
+  yaml: {
+    parse: (input: string) => yamlFormatter.fromFile(input),
+    stringify: (
+      metadata: object,
+      opts?: { sortedKeys?: string[]; comments?: Record<string, string> },
+    ) => {
+      const { sortedKeys, comments } = opts || {};
+      return yamlFormatter.toFile(metadata, sortedKeys, comments);
+    },
+  },
+};
+
+function inferFrontmatterFormat(str: string) {
+  const lineEnd = str.indexOf('\n');
+  const firstLine = str.slice(0, lineEnd !== -1 ? lineEnd : 0).trim();
+  if (firstLine.length > 3 && firstLine.slice(0, 3) === '---') {
+    // No need to infer, `gray-matter` will handle things like `---toml` for us.
+    return;
+  }
+  switch (firstLine) {
+    case '---':
+      return getFormatOpts(Languages.YAML);
+    case '+++':
+      return getFormatOpts(Languages.TOML);
+    case '{':
+      return getFormatOpts(Languages.JSON);
+    default:
+      console.warn('Unrecognized front-matter format.');
+  }
+}
+
+export function getFormatOpts(format?: Language, customDelimiter?: Delimiter) {
+  if (!format) {
+    return undefined;
+  }
+
+  const formats: { [key in Language]: Format } = {
+    yaml: { language: Languages.YAML, delimiters: '---' },
+    toml: { language: Languages.TOML, delimiters: '+++' },
+    json: { language: Languages.JSON, delimiters: ['{', '}'] },
+  };
+
+  const { language, delimiters } = formats[format];
+
+  return {
+    language,
+    delimiters: customDelimiter || delimiters,
+  };
+}
+
+export class FrontmatterFormatter {
+  format?: Format;
+
+  constructor(format?: Language, customDelimiter?: Delimiter) {
+    this.format = getFormatOpts(format, customDelimiter);
+  }
+
+  fromFile(content: string) {
+    const format = this.format || inferFrontmatterFormat(content);
+    const result = matter(content, { engines: parsers, ...format });
+    // in the absent of a body when serializing an entry we use an empty one
+    // when calling `toFile`, so we don't want to add it when parsing.
+    return {
+      ...result.data,
+      ...(result.content.trim() && { body: result.content }),
+    };
+  }
+
+  toFile(
+    data: { body?: string } & Record<string, unknown>,
+    sortedKeys?: string[],
+    comments?: Record<string, string>,
+  ) {
+    const { body = '', ...meta } = data;
+
+    // Stringify to YAML if the format was not set
+    const format = this.format || getFormatOpts(Languages.YAML);
+
+    // gray-matter always adds a line break at the end which trips our
+    // change detection logic
+    // https://github.com/jonschlinkert/gray-matter/issues/96
+    const trimLastLineBreak = body.slice(-1) !== '\n';
+    const file = matter.stringify(body, meta, {
+      engines: parsers,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore `sortedKeys` is not recognized by gray-matter, so it gets passed through to the parser
+      sortedKeys,
+      comments,
+      ...format,
+    });
+    return trimLastLineBreak && file.slice(-1) === '\n' ? file.slice(0, -1) : file;
+  }
+}
+
+export const FrontmatterInfer = new FrontmatterFormatter();
+
+export function frontmatterYAML(customDelimiter?: Delimiter) {
+  return new FrontmatterFormatter(Languages.YAML, customDelimiter);
+}
+
+export function frontmatterTOML(customDelimiter?: Delimiter) {
+  return new FrontmatterFormatter(Languages.TOML, customDelimiter);
+}
+
+export function frontmatterJSON(customDelimiter?: Delimiter) {
+  return new FrontmatterFormatter(Languages.JSON, customDelimiter);
+}

package/src/formats/helpers.ts

@@ -0,0 +1,14 @@
+export function sortKeys<Item>(
+  sortedKeys: string[],
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  selector: (a: Item) => string = (a: any) => a,
+) {
+  return (a: Item, b: Item) => {
+    const idxA = sortedKeys.indexOf(selector(a));
+    const idxB = sortedKeys.indexOf(selector(b));
+    if (idxA === -1 || idxB === -1) return 0;
+    if (idxA > idxB) return 1;
+    if (idxA < idxB) return -1;
+    return 0;
+  };
+}

package/src/formats/json.ts

@@ -0,0 +1,9 @@
+export default {
+  fromFile(content: string) {
+    return JSON.parse(content);
+  },
+
+  toFile(data: object) {
+    return JSON.stringify(data, null, 2);
+  },
+};

package/src/formats/toml.ts

@@ -0,0 +1,33 @@
+import parseToml from '@iarna/toml/parse-string';
+import tomlify from 'tomlify-j0.4';
+import dayjs from 'dayjs';
+
+import AssetProxy from '../valueObjects/AssetProxy';
+import { sortKeys } from './helpers';
+
+function outputReplacer(_key: string, value: unknown) {
+  if (dayjs.isDayjs(value)) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return value.format(value._f);
+  }
+  if (value instanceof AssetProxy) {
+    return `${value.path}`;
+  }
+  if (typeof value === 'number' && Number.isInteger(value)) {
+    // Return the string representation of integers so tomlify won't render with tenths (".0")
+    return value.toString();
+  }
+  // Return `false` to use default (`undefined` would delete key).
+  return false;
+}
+
+export default {
+  fromFile(content: string) {
+    return parseToml(content);
+  },
+
+  toFile(data: object, sortedKeys: string[] = []) {
+    return tomlify.toToml(data, { replace: outputReplacer, sort: sortKeys(sortedKeys) });
+  },
+};

package/src/formats/yaml.ts

@@ -0,0 +1,58 @@
+import yaml from 'yaml';
+
+import { sortKeys } from './helpers';
+
+import type { YAMLMap, YAMLSeq, Pair, Node } from 'yaml/types';
+
+function addComments(items: Array<Pair>, comments: Record<string, string>, prefix = '') {
+  items.forEach(item => {
+    if (item.key !== undefined) {
+      const itemKey = item.key.toString();
+      const key = prefix ? `${prefix}.${itemKey}` : itemKey;
+      if (comments[key]) {
+        const value = comments[key].split('\\n').join('\n ');
+        item.commentBefore = ` ${value}`;
+      }
+      if (Array.isArray(item.value?.items)) {
+        addComments(item.value.items, comments, key);
+      }
+    }
+  });
+}
+
+const timestampTag = {
+  identify: (value: unknown) => value instanceof Date,
+  default: true,
+  tag: '!timestamp',
+  test: RegExp(
+    '^' +
+      '([0-9]{4})-([0-9]{2})-([0-9]{2})' + // YYYY-MM-DD
+      'T' + // T
+      '([0-9]{2}):([0-9]{2}):([0-9]{2}(\\.[0-9]+)?)' + // HH:MM:SS(.ss)?
+      'Z' + // Z
+      '$',
+  ),
+  resolve: (str: string) => new Date(str),
+  stringify: (value: Node) => (value as Date).toISOString(),
+} as const;
+
+export default {
+  fromFile(content: string) {
+    if (content && content.trim().endsWith('---')) {
+      content = content.trim().slice(0, -3);
+    }
+    return yaml.parse(content, { customTags: [timestampTag] });
+  },
+
+  toFile(data: object, sortedKeys: string[] = [], comments: Record<string, string> = {}) {
+    const contents = yaml.createNode(data) as YAMLMap | YAMLSeq;
+
+    addComments(contents.items, comments);
+
+    contents.items.sort(sortKeys(sortedKeys, item => item.key?.toString()));
+    const doc = new yaml.Document();
+    doc.contents = contents;
+
+    return doc.toString();
+  },
+};

package/src/index.js

@@ -0,0 +1,8 @@
+import bootstrap from './bootstrap';
+import Registry from './lib/registry';
+
+export const DecapCmsCore = {
+  ...Registry,
+  init: bootstrap,
+};
+export default DecapCmsCore;

package/src/integrations/index.js

@@ -0,0 +1,35 @@
+import { Map } from 'immutable';
+
+import Algolia from './providers/algolia/implementation';
+import AssetStore from './providers/assetStore/implementation';
+
+export function resolveIntegrations(integrationsConfig, getToken) {
+  let integrationInstances = Map({});
+  integrationsConfig.get('providers').forEach((providerData, providerName) => {
+    switch (providerName) {
+      case 'algolia':
+        integrationInstances = integrationInstances.set('algolia', new Algolia(providerData));
+        break;
+      case 'assetStore':
+        integrationInstances = integrationInstances.set(
+          'assetStore',
+          new AssetStore(providerData, getToken),
+        );
+        break;
+    }
+  });
+  return integrationInstances;
+}
+
+export const getIntegrationProvider = (function () {
+  let integrations = null;
+
+  return (integrationsConfig, getToken, provider) => {
+    if (integrations) {
+      return integrations.get(provider);
+    } else {
+      integrations = resolveIntegrations(integrationsConfig, getToken);
+      return integrations.get(provider);
+    }
+  };
+})();

package/src/integrations/providers/algolia/implementation.js

@@ -0,0 +1,176 @@
+import flatten from 'lodash/flatten';
+import { unsentRequest } from 'decap-cms-lib-util';
+
+import { createEntry } from '../../../valueObjects/Entry';
+import { selectEntrySlug } from '../../../reducers/collections';
+
+const { fetchWithTimeout: fetch } = unsentRequest;
+
+function getSlug(path) {
+  return path
+    .split('/')
+    .pop()
+    .replace(/\.[^.]+$/, '');
+}
+
+export default class Algolia {
+  constructor(config) {
+    this.config = config;
+    if (config.get('applicationID') == null || config.get('apiKey') == null) {
+      throw 'The Algolia search integration needs the credentials (applicationID and apiKey) in the integration configuration.';
+    }
+
+    this.applicationID = config.get('applicationID');
+    this.apiKey = config.get('apiKey');
+
+    const prefix = config.get('indexPrefix');
+    this.indexPrefix = prefix ? `${prefix}-` : '';
+
+    this.searchURL = `https://${this.applicationID}-dsn.algolia.net/1`;
+
+    this.entriesCache = {
+      collection: null,
+      page: null,
+      entries: [],
+    };
+  }
+
+  requestHeaders(headers = {}) {
+    return {
+      'X-Algolia-API-Key': this.apiKey,
+      'X-Algolia-Application-Id': this.applicationID,
+      'Content-Type': 'application/json',
+      ...headers,
+    };
+  }
+
+  parseJsonResponse(response) {
+    return response.json().then(json => {
+      if (!response.ok) {
+        return Promise.reject(json);
+      }
+
+      return json;
+    });
+  }
+
+  urlFor(path, options) {
+    const params = [];
+    if (options.params) {
+      for (const key in options.params) {
+        params.push(`${key}=${encodeURIComponent(options.params[key])}`);
+      }
+    }
+    if (params.length) {
+      path += `?${params.join('&')}`;
+    }
+    return path;
+  }
+
+  request(path, options = {}) {
+    const headers = this.requestHeaders(options.headers || {});
+    const url = this.urlFor(path, options);
+    return fetch(url, { ...options, headers }).then(response => {
+      const contentType = response.headers.get('Content-Type');
+      if (contentType && contentType.match(/json/)) {
+        return this.parseJsonResponse(response);
+      }
+
+      return response.text();
+    });
+  }
+
+  search(collections, searchTerm, page) {
+    const searchCollections = collections.map(collection => ({
+      indexName: `${this.indexPrefix}${collection}`,
+      params: `query=${searchTerm}&page=${page}`,
+    }));
+
+    return this.request(`${this.searchURL}/indexes/*/queries`, {
+      method: 'POST',
+      body: JSON.stringify({ requests: searchCollections }),
+    }).then(response => {
+      const entries = response.results.map((result, index) =>
+        result.hits.map(hit => {
+          const slug = getSlug(hit.path);
+          return createEntry(collections[index], slug, hit.path, { data: hit.data, partial: true });
+        }),
+      );
+
+      return { entries: flatten(entries), pagination: page };
+    });
+  }
+
+  searchBy(field, collection, query) {
+    return this.request(`${this.searchURL}/indexes/${this.indexPrefix}${collection}`, {
+      params: {
+        restrictSearchableAttributes: field,
+        query,
+      },
+    });
+  }
+
+  listEntries(collection, page) {
+    if (this.entriesCache.collection === collection && this.entriesCache.page === page) {
+      return Promise.resolve({ page: this.entriesCache.page, entries: this.entriesCache.entries });
+    } else {
+      return this.request(
+        `${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`,
+        {
+          params: { page },
+        },
+      ).then(response => {
+        const entries = response.hits.map(hit => {
+          const slug = selectEntrySlug(collection, hit.path);
+          return createEntry(collection.get('name'), slug, hit.path, {
+            data: hit.data,
+            partial: true,
+          });
+        });
+        this.entriesCache = { collection, pagination: response.page, entries };
+        return { entries, pagination: response.page };
+      });
+    }
+  }
+
+  async listAllEntries(collection) {
+    const params = {
+      hitsPerPage: 1000,
+    };
+    let response = await this.request(
+      `${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`,
+      { params },
+    );
+    let { nbPages = 0, hits, page } = response;
+    page = page + 1;
+    while (page < nbPages) {
+      response = await this.request(
+        `${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`,
+        {
+          params: { ...params, page },
+        },
+      );
+      hits = [...hits, ...response.hits];
+      page = page + 1;
+    }
+    const entries = hits.map(hit => {
+      const slug = selectEntrySlug(collection, hit.path);
+      return createEntry(collection.get('name'), slug, hit.path, {
+        data: hit.data,
+        partial: true,
+      });
+    });
+
+    return entries;
+  }
+
+  getEntry(collection, slug) {
+    return this.searchBy('slug', collection.get('name'), slug).then(response => {
+      const entry = response.hits.filter(hit => hit.slug === slug)[0];
+      return createEntry(collection.get('name'), slug, entry.path, {
+        data: entry.data,
+        partial: true,
+      });
+    });
+  }
+}

package/src/integrations/providers/assetStore/implementation.js

@@ -0,0 +1,148 @@
+import pickBy from 'lodash/pickBy';
+import trimEnd from 'lodash/trimEnd';
+import { unsentRequest } from 'decap-cms-lib-util';
+
+import { addParams } from '../../../lib/urlHelper';
+
+const { fetchWithTimeout: fetch } = unsentRequest;
+
+export default class AssetStore {
+  constructor(config, getToken) {
+    this.config = config;
+    if (config.get('getSignedFormURL') == null) {
+      throw 'The AssetStore integration needs the getSignedFormURL in the integration configuration.';
+    }
+    this.getToken = getToken;
+
+    this.shouldConfirmUpload = config.get('shouldConfirmUpload', false);
+    this.getSignedFormURL = trimEnd(config.get('getSignedFormURL'), '/');
+  }
+
+  parseJsonResponse(response) {
+    return response.json().then(json => {
+      if (!response.ok) {
+        return Promise.reject(json);
+      }
+
+      return json;
+    });
+  }
+
+  urlFor(path, options) {
+    const params = [];
+    if (options.params) {
+      for (const key in options.params) {
+        params.push(`${key}=${encodeURIComponent(options.params[key])}`);
+      }
+    }
+    if (params.length) {
+      path += `?${params.join('&')}`;
+    }
+    return path;
+  }
+
+  requestHeaders(headers = {}) {
+    return {
+      ...headers,
+    };
+  }
+
+  confirmRequest(assetID) {
+    this.getToken().then(token =>
+      this.request(`${this.getSignedFormURL}/${assetID}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ state: 'uploaded' }),
+      }),
+    );
+  }
+
+  async request(path, options = {}) {
+    const headers = this.requestHeaders(options.headers || {});
+    const url = this.urlFor(path, options);
+    const response = await fetch(url, { ...options, headers });
+    const contentType = response.headers.get('Content-Type');
+    const isJson = contentType && contentType.match(/json/);
+    const content = isJson ? await this.parseJsonResponse(response) : response.text();
+    return content;
+  }
+
+  async retrieve(query, page, privateUpload) {
+    const params = pickBy(
+      { search: query, page, filter: privateUpload ? 'private' : 'public' },
+      val => !!val,
+    );
+    const url = addParams(this.getSignedFormURL, params);
+    const token = await this.getToken();
+    const headers = {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    };
+    const response = await this.request(url, { headers });
+    const files = response.map(({ id, name, size, url }) => {
+      return { id, name, size, displayURL: url, url, path: url };
+    });
+    return files;
+  }
+
+  delete(assetID) {
+    const url = `${this.getSignedFormURL}/${assetID}`;
+    return this.getToken().then(token =>
+      this.request(url, {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+      }),
+    );
+  }
+
+  async upload(file, privateUpload = false) {
+    const fileData = {
+      name: file.name,
+      size: file.size,
+    };
+    if (file.type) {
+      fileData.content_type = file.type;
+    }
+
+    if (privateUpload) {
+      fileData.visibility = 'private';
+    }
+
+    try {
+      const token = await this.getToken();
+      const response = await this.request(this.getSignedFormURL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(fileData),
+      });
+      const formURL = response.form.url;
+      const formFields = response.form.fields;
+      const { id, name, size, url } = response.asset;
+
+      const formData = new FormData();
+      Object.keys(formFields).forEach(key => formData.append(key, formFields[key]));
+      formData.append('file', file, file.name);
+
+      await this.request(formURL, { method: 'POST', body: formData });
+
+      if (this.shouldConfirmUpload) {
+        await this.confirmRequest(id);
+      }
+
+      const asset = { id, name, size, displayURL: url, url, path: url };
+      return { success: true, asset };
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+}