@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/integrations/providers/assetStore/implementation.js

@@ -0,0 +1,165 @@
+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;
+    }
+  }
+}

package/dist/esm/lib/consoleError.js

@@ -0,0 +1,3 @@
+export default function consoleError(title, description) {
+  console.error(`%c ⛔ ${title}\n` + `%c${description}\n\n`, 'color: black; font-weight: bold; font-size: 16px; line-height: 50px;', 'color: black;');
+}

package/dist/esm/lib/formatters.js

@@ -0,0 +1,191 @@
+import flow from 'lodash/flow';
+import partialRight from 'lodash/partialRight';
+import trimEnd from 'lodash/trimEnd';
+import trimStart from 'lodash/trimStart';
+import { stringTemplate } from 'decap-cms-lib-widgets';
+import { stripIndent } from 'common-tags';
+import { selectIdentifier, selectField, selectInferredField, getFileFromSlug } from '../reducers/collections';
+import { sanitizeSlug } from './urlHelper';
+import { FILES } from '../constants/collectionTypes';
+import { COMMIT_AUTHOR, COMMIT_DATE } from '../constants/commitProps';
+const {
+  compileStringTemplate,
+  parseDateFromEntry,
+  parseDateFromEntryData,
+  SLUG_MISSING_REQUIRED_DATE,
+  keyToPathArray,
+  addFileTemplateFields
+} = stringTemplate;
+const commitMessageTemplates = {
+  create: 'Create {{collection}} “{{slug}}”',
+  update: 'Update {{collection}} “{{slug}}”',
+  delete: 'Delete {{collection}} “{{slug}}”',
+  uploadMedia: 'Upload “{{path}}”',
+  deleteMedia: 'Delete “{{path}}”',
+  openAuthoring: '{{message}}'
+};
+const variableRegex = /\{\{([^}]+)\}\}/g;
+export function commitMessageFormatter(type, config, {
+  slug,
+  path,
+  collection,
+  authorLogin,
+  authorName
+}, isOpenAuthoring) {
+  const templates = {
+    ...commitMessageTemplates,
+    ...(config.backend.commit_messages || {})
+  };
+  const commitMessage = templates[type].replace(variableRegex, (_, variable) => {
+    switch (variable) {
+      case 'slug':
+        return slug || '';
+      case 'path':
+        return path || '';
+      case 'collection':
+        return collection ? collection.get('label_singular') || collection.get('label') : '';
+      case 'author-login':
+        return authorLogin || '';
+      case 'author-name':
+        return authorName || '';
+      default:
+        console.warn(`Ignoring unknown variable “${variable}” in commit message template.`);
+        return '';
+    }
+  });
+  if (!isOpenAuthoring) {
+    return commitMessage;
+  }
+  const message = templates.openAuthoring.replace(variableRegex, (_, variable) => {
+    switch (variable) {
+      case 'message':
+        return commitMessage;
+      case 'author-login':
+        return authorLogin || '';
+      case 'author-name':
+        return authorName || '';
+      default:
+        console.warn(`Ignoring unknown variable “${variable}” in open authoring message template.`);
+        return '';
+    }
+  });
+  return message;
+}
+export function prepareSlug(slug, preserveCase = false) {
+  let result = slug.trim();
+
+  // Convert slug to lower-case (unless preserveCase is true)
+  if (!preserveCase) {
+    result = result.toLocaleLowerCase();
+  }
+  return result
+  // Remove single quotes.
+  .replace(/[']/g, '')
+
+  // Replace periods with dashes.
+  .replace(/[.]/g, '-');
+}
+export function getProcessSegment(slugConfig, ignoreValues, preserveCase = false) {
+  return value => ignoreValues && ignoreValues.includes(value) ? value : flow([value => String(value), value => prepareSlug(value, preserveCase), partialRight(sanitizeSlug, slugConfig)])(value);
+}
+export function slugFormatter(collection, entryData, slugConfig) {
+  const slugTemplate = collection.get('slug') || '{{slug}}';
+  const identifier = entryData.getIn(keyToPathArray(selectIdentifier(collection)));
+  if (!identifier) {
+    throw new Error('Collection must have a field name that is a valid entry identifier, or must have `identifier_field` set');
+  }
+  const processSegment = getProcessSegment(slugConfig);
+  const date = parseDateFromEntryData(entryData, selectInferredField(collection, 'date')) || new Date(Date.now());
+  const slug = compileStringTemplate(slugTemplate, date, identifier, entryData, processSegment);
+  if (!collection.has('path')) {
+    return slug;
+  } else {
+    const pathTemplate = prepareSlug(collection.get('path'));
+    return compileStringTemplate(pathTemplate, date, slug, entryData, value => value === slug ? value : processSegment(value));
+  }
+}
+export function previewUrlFormatter(baseUrl, collection, slug, entry, slugConfig) {
+  /**
+   * Preview URL can't be created without `baseUrl`. This makes preview URLs
+   * optional for backends that don't support them.
+   */
+  if (!baseUrl) {
+    return;
+  }
+  const basePath = trimEnd(baseUrl, '/');
+  const isFileCollection = collection.get('type') === FILES;
+  const file = isFileCollection ? getFileFromSlug(collection, entry.get('slug')) : undefined;
+  function getPathTemplate() {
+    return file?.get('preview_path') ?? collection.get('preview_path');
+  }
+  function getDateField() {
+    return file?.get('preview_path_date_field') ?? collection.get('preview_path_date_field');
+  }
+
+  /**
+   * If a `previewPath` is provided for the collection/file, use it to construct the
+   * URL path.
+   */
+  const pathTemplate = getPathTemplate();
+
+  /**
+   * Without a `previewPath` for the collection/file (via config), the preview URL
+   * will be the URL provided by the backend.
+   */
+  if (!pathTemplate) {
+    return baseUrl;
+  }
+  let fields = entry.get('data');
+  fields = addFileTemplateFields(entry.get('path'), fields, collection.get('folder'));
+  const dateFieldName = getDateField() || selectInferredField(collection, 'date');
+  const date = parseDateFromEntry(entry, dateFieldName);
+
+  // Prepare and sanitize slug variables only, leave the rest of the
+  // `preview_path` template as is.
+  const processSegment = getProcessSegment(slugConfig, [fields.get('dirname')]);
+  let compiledPath;
+  try {
+    compiledPath = compileStringTemplate(pathTemplate, date, slug, fields, processSegment);
+  } catch (err) {
+    // Print an error and ignore `preview_path` if both:
+    //   1. Date is invalid (according to DayJs), and
+    //   2. A date expression (eg. `{{year}}`) is used in `preview_path`
+    if (err.name === SLUG_MISSING_REQUIRED_DATE) {
+      console.error(stripIndent`
+        Collection "${collection.get('name')}" configuration error:
+          \`preview_path_date_field\` must be a field with a valid date. Ignoring \`preview_path\`.
+      `);
+      return basePath;
+    }
+    throw err;
+  }
+  const previewPath = trimStart(compiledPath, ' /');
+  return `${basePath}/${previewPath}`;
+}
+export function summaryFormatter(summaryTemplate, entry, collection) {
+  let entryData = entry.get('data');
+  const date = parseDateFromEntry(entry, selectInferredField(collection, 'date')) || null;
+  const identifier = entryData.getIn(keyToPathArray(selectIdentifier(collection)));
+  entryData = addFileTemplateFields(entry.get('path'), entryData, collection.get('folder'));
+  // allow commit information in summary template
+  if (entry.get('author') && !selectField(collection, COMMIT_AUTHOR)) {
+    entryData = entryData.set(COMMIT_AUTHOR, entry.get('author'));
+  }
+  if (entry.get('updatedOn') && !selectField(collection, COMMIT_DATE)) {
+    entryData = entryData.set(COMMIT_DATE, entry.get('updatedOn'));
+  }
+  const summary = compileStringTemplate(summaryTemplate, date, identifier, entryData);
+  return summary;
+}
+export function folderFormatter(folderTemplate, entry, collection, defaultFolder, folderKey, slugConfig) {
+  if (!entry || !entry.get('data')) {
+    return folderTemplate;
+  }
+  let fields = entry.get('data').set(folderKey, defaultFolder);
+  fields = addFileTemplateFields(entry.get('path'), fields, collection.get('folder'));
+  const date = parseDateFromEntry(entry, selectInferredField(collection, 'date')) || null;
+  const identifier = fields.getIn(keyToPathArray(selectIdentifier(collection)));
+  const processSegment = getProcessSegment(slugConfig, [defaultFolder, fields.get('dirname')]);
+  const mediaFolder = compileStringTemplate(folderTemplate, date, identifier, fields, processSegment);
+  return mediaFolder;
+}