decap-cms-core
Version:
Decap CMS core application, see decap-cms package for the main distribution.
1,176 lines (1,164 loc) • 41.7 kB
JavaScript
import attempt from 'lodash/attempt';
import flatten from 'lodash/flatten';
import isError from 'lodash/isError';
import uniq from 'lodash/uniq';
import trim from 'lodash/trim';
import sortBy from 'lodash/sortBy';
import get from 'lodash/get';
import set from 'lodash/set';
import { List, fromJS, Set } from 'immutable';
import * as fuzzy from 'fuzzy';
import { localForage, Cursor, CURSOR_COMPATIBILITY_SYMBOL, getPathDepth, blobToFileObj, asyncLock, EDITORIAL_WORKFLOW_ERROR } from 'decap-cms-lib-util';
import { basename, join, extname, dirname } from 'path';
import { stringTemplate } from 'decap-cms-lib-widgets';
import { resolveFormat } from './formats/formats';
import { selectUseWorkflow } from './reducers/config';
import { selectMediaFilePath, selectEntry } from './reducers/entries';
import { selectIntegration } from './reducers/integrations';
import { selectEntrySlug, selectEntryPath, selectFileEntryLabel, selectAllowNewEntries, selectAllowDeletion, selectFolderEntryExtension, selectInferredField, selectMediaFolders, selectFieldsComments, selectHasMetaPath } from './reducers/collections';
import { createEntry } from './valueObjects/Entry';
import { sanitizeChar } from './lib/urlHelper';
import { getBackend, invokeEvent } from './lib/registry';
import { commitMessageFormatter, slugFormatter, previewUrlFormatter } from './lib/formatters';
import { status } from './constants/publishModes';
import { FOLDER, FILES } from './constants/collectionTypes';
import { selectCustomPath } from './reducers/entryDraft';
import { getI18nFilesDepth, getI18nFiles, hasI18n, getFilePaths, getI18nEntry, groupEntries, getI18nDataFiles, getI18nBackup, formatI18nBackup, getI18nInfo, I18N_STRUCTURE } from './lib/i18n';
const {
extractTemplateVars,
dateParsers,
expandPath
} = stringTemplate;
function updateAssetProxies(assetProxies, config, collection, entryDraft, path) {
assetProxies.map(asset => {
// update media files path based on entry path
const oldPath = asset.path;
const newPath = selectMediaFilePath(config, collection, entryDraft.get('entry').set('path', path), oldPath, asset.field);
asset.path = newPath;
});
}
export class LocalStorageAuthStore {
storageKey = 'decap-cms-user';
retrieve() {
const data = window.localStorage.getItem(this.storageKey);
return data && JSON.parse(data);
}
store(userData) {
window.localStorage.setItem(this.storageKey, JSON.stringify(userData));
}
logout() {
window.localStorage.removeItem(this.storageKey);
}
}
function getEntryBackupKey(collectionName, slug) {
const baseKey = 'backup';
if (!collectionName) {
return baseKey;
}
const suffix = slug ? `.${slug}` : '';
return `${baseKey}.${collectionName}${suffix}`;
}
function getEntryField(field, entry) {
const value = get(entry.data, field);
if (value) {
return String(value);
} else {
const firstFieldPart = field.split('.')[0];
if (entry[firstFieldPart]) {
// allows searching using entry.slug/entry.path etc.
return entry[firstFieldPart];
} else {
return '';
}
}
}
export function extractSearchFields(searchFields) {
return entry => searchFields.reduce((acc, field) => {
const value = getEntryField(field, entry);
if (value) {
return `${acc} ${value}`;
} else {
return acc;
}
}, '');
}
export function expandSearchEntries(entries, searchFields) {
// expand the entries for the purpose of the search
const expandedEntries = entries.reduce((acc, e) => {
const expandedFields = searchFields.reduce((acc, f) => {
const fields = expandPath({
data: e.data,
path: f
});
acc.push(...fields);
return acc;
}, []);
for (let i = 0; i < expandedFields.length; i++) {
acc.push({
...e,
field: expandedFields[i]
});
}
return acc;
}, []);
return expandedEntries;
}
export function mergeExpandedEntries(entries) {
// merge the search results by slug and only keep data that matched the search
const fields = entries.map(f => f.field);
const arrayPaths = {};
const merged = entries.reduce((acc, e) => {
if (!acc[e.slug]) {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const {
field,
...rest
} = e;
acc[e.slug] = rest;
arrayPaths[e.slug] = Set();
}
const nestedFields = e.field.split('.');
let value = acc[e.slug].data;
for (let i = 0; i < nestedFields.length; i++) {
value = value[nestedFields[i]];
if (Array.isArray(value)) {
const path = nestedFields.slice(0, i + 1).join('.');
arrayPaths[e.slug] = arrayPaths[e.slug].add(path);
}
}
return acc;
}, {});
// this keeps the search score sorting order designated by the order in entries
// and filters non matching items
Object.keys(merged).forEach(slug => {
const data = merged[slug].data;
for (const path of arrayPaths[slug].toArray()) {
const array = get(data, path);
const filtered = array.filter((_, index) => {
return fields.some(f => `${f}.`.startsWith(`${path}.${index}.`));
});
filtered.sort((a, b) => {
const indexOfA = array.indexOf(a);
const indexOfB = array.indexOf(b);
const pathOfA = `${path}.${indexOfA}.`;
const pathOfB = `${path}.${indexOfB}.`;
const matchingFieldIndexA = fields.findIndex(f => `${f}.`.startsWith(pathOfA));
const matchingFieldIndexB = fields.findIndex(f => `${f}.`.startsWith(pathOfB));
return matchingFieldIndexA - matchingFieldIndexB;
});
set(data, path, filtered);
}
});
return Object.values(merged);
}
function sortByScore(a, b) {
if (a.score > b.score) return -1;
if (a.score < b.score) return 1;
return 0;
}
export function slugFromCustomPath(collection, customPath) {
const folderPath = collection.get('folder', '');
const entryPath = customPath.toLowerCase().replace(folderPath.toLowerCase(), '');
const slug = join(dirname(trim(entryPath, '/')), basename(entryPath, extname(customPath)));
return slug;
}
function prepareMetaPath(path, collection) {
if (!selectHasMetaPath(collection)) {
return path;
}
const dir = dirname(path);
return dir.slice(collection.get('folder').length + 1) || '/';
}
function collectionDepth(collection) {
let depth;
depth = collection.get('nested')?.get('depth') || getPathDepth(collection.get('path', ''));
if (hasI18n(collection)) {
depth = getI18nFilesDepth(collection, depth);
}
return depth;
}
function i18nRulestring(ruleString, {
defaultLocale,
structure
}) {
if (structure === I18N_STRUCTURE.MULTIPLE_FOLDERS) {
return `${defaultLocale}\\/${ruleString}`;
}
if (structure === I18N_STRUCTURE.MULTIPLE_FILES) {
return `${ruleString}\\.${defaultLocale}\\..*`;
}
return ruleString;
}
function collectionRegex(collection) {
let ruleString = '';
if (collection.get('path')) {
ruleString = `${collection.get('folder')}/${collection.get('path')}`.replace(/{{.*}}/gm, '(.*)');
}
if (hasI18n(collection)) {
ruleString = i18nRulestring(ruleString, getI18nInfo(collection));
}
return ruleString ? new RegExp(ruleString) : undefined;
}
export class Backend {
constructor(implementation, {
backendName,
authStore,
config
}) {
// We can't reliably run this on exit, so we do cleanup on load.
this.deleteAnonymousBackup();
this.config = config;
this.implementation = implementation.init(this.config, {
useWorkflow: selectUseWorkflow(this.config),
updateUserCredentials: this.updateUserCredentials,
initialWorkflowStatus: status.first()
});
this.backendName = backendName;
this.authStore = authStore;
if (this.implementation === null) {
throw new Error('Cannot instantiate a Backend with no implementation');
}
this.backupSync = asyncLock();
}
async status() {
const attempts = 3;
let status = {
auth: {
status: true
},
api: {
status: true,
statusPage: ''
}
};
for (let i = 1; i <= attempts; i++) {
status = await this.implementation.status();
// return on first success
if (Object.values(status).every(s => s.status === true)) {
return status;
} else {
await new Promise(resolve => setTimeout(resolve, i * 1000));
}
}
return status;
}
currentUser() {
if (this.user) {
return this.user;
}
const stored = this.authStore.retrieve();
if (stored && stored.backendName === this.backendName) {
return Promise.resolve(this.implementation.restoreUser(stored)).then(user => {
this.user = {
...user,
backendName: this.backendName
};
// return confirmed/rehydrated user object instead of stored
this.authStore.store(this.user);
return this.user;
});
}
return Promise.resolve(null);
}
isGitBackend() {
return this.implementation.isGitBackend?.() || false;
}
updateUserCredentials = updatedCredentials => {
const storedUser = this.authStore.retrieve();
if (storedUser && storedUser.backendName === this.backendName) {
this.user = {
...storedUser,
...updatedCredentials
};
this.authStore.store(this.user);
return this.user;
}
};
authComponent() {
return this.implementation.authComponent();
}
authenticate(credentials) {
return this.implementation.authenticate(credentials).then(user => {
this.user = {
...user,
backendName: this.backendName
};
if (this.authStore) {
this.authStore.store(this.user);
}
return this.user;
});
}
async logout() {
try {
await this.implementation.logout();
} catch (e) {
console.warn('Error during logout', e.message);
} finally {
this.user = null;
if (this.authStore) {
this.authStore.logout();
}
}
}
getToken = () => this.implementation.getToken();
async entryExist(collection, path, slug, useWorkflow) {
const unpublishedEntry = useWorkflow && (await this.implementation.unpublishedEntry({
collection: collection.get('name'),
slug
}).catch(error => {
if (error.name === EDITORIAL_WORKFLOW_ERROR && error.notUnderEditorialWorkflow) {
return Promise.resolve(false);
}
return Promise.reject(error);
}));
if (unpublishedEntry) return unpublishedEntry;
const publishedEntry = await this.implementation.getEntry(path).then(({
data
}) => data).catch(() => {
return Promise.resolve(false);
});
return publishedEntry;
}
async generateUniqueSlug(collection, entryData, config, usedSlugs, customPath) {
const slugConfig = config.slug;
let slug;
if (customPath) {
slug = slugFromCustomPath(collection, customPath);
} else {
slug = slugFormatter(collection, entryData, slugConfig);
}
let i = 1;
let uniqueSlug = slug;
// Check for duplicate slug in loaded entities store first before repo
while (usedSlugs.includes(uniqueSlug) || (await this.entryExist(collection, selectEntryPath(collection, uniqueSlug), uniqueSlug, selectUseWorkflow(config)))) {
uniqueSlug = `${slug}${sanitizeChar(' ', slugConfig)}${i++}`;
}
return uniqueSlug;
}
async entrySlugsForCollectionLimit(collection, config, usedSlugs) {
const publishedEntries = await this.listAllEntries(collection);
let entrySlugs = Set(publishedEntries.map(entry => entry.slug)).union(usedSlugs);
if (selectUseWorkflow(config)) {
const unpublishedEntryIds = await this.implementation.unpublishedEntries();
const unpublishedEntries = await Promise.all(unpublishedEntryIds.map(id => this.implementation.unpublishedEntry({
id
})));
const collectionName = collection.get('name');
unpublishedEntries.forEach(entry => {
if (entry.collection === collectionName) {
entrySlugs = entrySlugs.add(entry.slug);
}
});
}
return entrySlugs;
}
processEntries(loadedEntries, collection) {
const entries = loadedEntries.map(loadedEntry => createEntry(collection.get('name'), selectEntrySlug(collection, loadedEntry.file.path), loadedEntry.file.path, {
raw: loadedEntry.data || '',
label: loadedEntry.file.label,
author: loadedEntry.file.author,
updatedOn: loadedEntry.file.updatedOn,
meta: {
path: prepareMetaPath(loadedEntry.file.path, collection)
}
}));
const formattedEntries = entries.map(this.entryWithFormat(collection));
// If this collection has a "filter" property, filter entries accordingly
const collectionFilter = collection.get('filter');
const filteredEntries = collectionFilter ? this.filterEntries({
entries: formattedEntries
}, collectionFilter) : formattedEntries;
if (hasI18n(collection)) {
const extension = selectFolderEntryExtension(collection);
const groupedEntries = groupEntries(collection, extension, filteredEntries);
return groupedEntries;
}
return filteredEntries;
}
async listEntries(collection) {
const extension = selectFolderEntryExtension(collection);
let listMethod;
const collectionType = collection.get('type');
if (collectionType === FOLDER) {
listMethod = () => {
const depth = collectionDepth(collection);
return this.implementation.entriesByFolder(collection.get('folder'), extension, depth);
};
} else if (collectionType === FILES) {
const files = collection.get('files').map(collectionFile => ({
path: collectionFile.get('file'),
label: collectionFile.get('label')
})).toArray();
listMethod = () => this.implementation.entriesByFiles(files);
} else {
throw new Error(`Unknown collection type: ${collectionType}`);
}
const loadedEntries = await listMethod();
/*
Wrap cursors so we can tell which collection the cursor is
from. This is done to prevent traverseCursor from requiring a
`collection` argument.
*/
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
const cursor = Cursor.create(loadedEntries[CURSOR_COMPATIBILITY_SYMBOL]).wrapData({
cursorType: 'collectionEntries',
collection
});
return {
entries: this.processEntries(loadedEntries, collection),
pagination: cursor.meta?.get('page'),
cursor
};
}
async getNotes(collection, slug) {
if (typeof this.implementation.getNotes === 'function') {
return this.implementation.getNotes(collection, slug);
}
// If backend doesn't support notes, return empty array
console.warn(`Backend '${this.backendName}' does not support notes`);
return [];
}
async addNote(collection, slug, note) {
if (typeof this.implementation.addNote === 'function') {
return this.implementation.addNote(collection, slug, note);
}
throw new Error(`Backend '${this.backendName}' does not support adding notes`);
}
async updateNote(collection, slug, noteId, updates) {
if (typeof this.implementation.updateNote === 'function') {
return this.implementation.updateNote(collection, slug, noteId, updates);
}
throw new Error(`Backend '${this.backendName}' does not support updating notes`);
}
async deleteNote(collection, slug, noteId) {
if (typeof this.implementation.deleteNote === 'function') {
return this.implementation.deleteNote(collection, slug, noteId);
}
throw new Error(`Backend '${this.backendName}' does not support deleting notes`);
}
async toggleNoteResolution(collection, slug, noteId) {
if (typeof this.implementation.toggleNoteResolution === 'function') {
return this.implementation.toggleNoteResolution(collection, slug, noteId);
}
throw new Error(`Backend '${this.backendName}' does not support toggling note resolution`);
}
async startNotesPolling(collection, slug, callbacks) {
if (!this.implementation.startNotesPolling) {
console.warn('Backend does not support notes polling');
return;
}
return this.implementation.startNotesPolling(collection, slug, callbacks);
}
async stopNotesPolling(collection, slug) {
if (typeof this.implementation.stopNotesPolling === 'function') {
return this.implementation.stopNotesPolling(collection, slug);
}
}
async refreshNotesNow(collection, slug) {
if (typeof this.implementation.refreshNotesNow === 'function') {
return this.implementation.refreshNotesNow(collection, slug);
}
// Fallback: just reload notes without polling
console.warn(`Backend '${this.backendName}' does not support manual refresh`);
}
reopenIssueForUnpublishedEntry(collection, slug) {
if (typeof this.implementation.reopenIssueForUnpublishedEntry === 'function') {
return this.implementation.reopenIssueForUnpublishedEntry(collection, slug);
}
// If backend doesn't support this, silently skip
return Promise.resolve();
}
async getPRMetadata(collection, slug) {
if (typeof this.implementation.getPRMetadata === 'function') {
return this.implementation.getPRMetadata(collection, slug);
}
return null;
}
// The same as listEntries, except that if a cursor with the "next"
// action available is returned, it calls "next" on the cursor and
// repeats the process. Once there is no available "next" action, it
// returns all the collected entries. Used to retrieve all entries
// for local searches and queries.
async listAllEntries(collection) {
if (collection.get('folder') && this.implementation.allEntriesByFolder) {
const depth = collectionDepth(collection);
const extension = selectFolderEntryExtension(collection);
return this.implementation.allEntriesByFolder(collection.get('folder'), extension, depth, collectionRegex(collection)).then(entries => this.processEntries(entries, collection));
}
const response = await this.listEntries(collection);
const {
entries
} = response;
let {
cursor
} = response;
while (cursor && cursor.actions.includes('next')) {
const {
entries: newEntries,
cursor: newCursor
} = await this.traverseCursor(cursor, 'next');
entries.push(...newEntries);
cursor = newCursor;
}
return entries;
}
async search(collections, searchTerm) {
// Perform a local search by requesting all entries. For each
// collection, load it, search, and call onCollectionResults with
// its results.
const errors = [];
const collectionEntriesRequests = collections.map(async collection => {
const summary = collection.get('summary', '');
const summaryFields = extractTemplateVars(summary);
// TODO: pass search fields in as an argument
let searchFields = [];
if (collection.get('type') === FILES) {
collection.get('files')?.forEach(f => {
const topLevelFields = f.get('fields').map(f => f.get('name')).toArray();
searchFields = [...searchFields, ...topLevelFields];
});
} else {
searchFields = [selectInferredField(collection, 'title'), selectInferredField(collection, 'shortTitle'), selectInferredField(collection, 'author'), ...summaryFields.map(elem => {
if (dateParsers[elem]) {
return selectInferredField(collection, 'date');
}
return elem;
})];
}
const filteredSearchFields = searchFields.filter(Boolean);
const collectionEntries = await this.listAllEntries(collection);
return fuzzy.filter(searchTerm, collectionEntries, {
extract: extractSearchFields(uniq(filteredSearchFields))
});
}).map(p => p.catch(err => {
errors.push(err);
return [];
}));
const entries = await Promise.all(collectionEntriesRequests).then(arrays => flatten(arrays));
if (errors.length > 0) {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
throw new Error({
message: 'Errors occurred while searching entries locally!',
errors
});
}
const hits = entries.filter(({
score
}) => score > 5).sort(sortByScore).map(f => f.original);
return {
entries: hits
};
}
async query(collection, searchFields, searchTerm, file, limit) {
let entries = await this.listAllEntries(collection);
if (file) {
entries = entries.filter(e => e.slug === file);
}
const expandedEntries = expandSearchEntries(entries, searchFields);
let hits = fuzzy.filter(searchTerm, expandedEntries, {
extract: entry => {
return getEntryField(entry.field, entry);
}
}).sort(sortByScore).map(f => f.original);
if (limit !== undefined && limit > 0) {
hits = hits.slice(0, limit);
}
const merged = mergeExpandedEntries(hits);
return {
query: searchTerm,
hits: merged
};
}
traverseCursor(cursor, action) {
const [data, unwrappedCursor] = cursor.unwrapData();
// TODO: stop assuming all cursors are for collections
const collection = data.get('collection');
return this.implementation.traverseCursor(unwrappedCursor, action).then(async ({
entries,
cursor: newCursor
}) => ({
entries: this.processEntries(entries, collection),
cursor: Cursor.create(newCursor).wrapData({
cursorType: 'collectionEntries',
collection
})
}));
}
async getLocalDraftBackup(collection, slug) {
const key = getEntryBackupKey(collection.get('name'), slug);
const backup = await localForage.getItem(key);
if (!backup || !backup.raw.trim()) {
return {};
}
const {
raw,
path
} = backup;
let {
mediaFiles = []
} = backup;
mediaFiles = mediaFiles.map(file => {
// de-serialize the file object
if (file.file) {
return {
...file,
url: URL.createObjectURL(file.file)
};
}
return file;
});
const label = selectFileEntryLabel(collection, slug);
const formatRawData = raw => {
return this.entryWithFormat(collection)(createEntry(collection.get('name'), slug, path, {
raw,
label,
mediaFiles,
meta: {
path: prepareMetaPath(path, collection)
}
}));
};
const entry = formatRawData(raw);
if (hasI18n(collection) && backup.i18n) {
const i18n = formatI18nBackup(backup.i18n, formatRawData);
entry.i18n = i18n;
}
return {
entry
};
}
async persistLocalDraftBackup(entry, collection) {
try {
await this.backupSync.acquire();
const key = getEntryBackupKey(collection.get('name'), entry.get('slug'));
const raw = this.entryToRaw(collection, entry);
if (!raw.trim()) {
return;
}
const mediaFiles = await Promise.all(entry.get('mediaFiles').toJS().map(async file => {
// make sure to serialize the file
if (file.url?.startsWith('blob:')) {
const blob = await fetch(file.url).then(res => res.blob());
return {
...file,
file: blobToFileObj(file.name, blob)
};
}
return file;
}));
let i18n;
if (hasI18n(collection)) {
i18n = getI18nBackup(collection, entry, entry => this.entryToRaw(collection, entry));
}
await localForage.setItem(key, {
raw,
path: entry.get('path'),
mediaFiles,
...(i18n && {
i18n
})
});
const result = await localForage.setItem(getEntryBackupKey(), raw);
return result;
} catch (e) {
console.warn('persistLocalDraftBackup', e);
} finally {
this.backupSync.release();
}
}
async deleteLocalDraftBackup(collection, slug) {
try {
await this.backupSync.acquire();
await localForage.removeItem(getEntryBackupKey(collection.get('name'), slug));
// delete new entry backup if not deleted
slug && (await localForage.removeItem(getEntryBackupKey(collection.get('name'))));
const result = await this.deleteAnonymousBackup();
return result;
} catch (e) {
console.warn('deleteLocalDraftBackup', e);
} finally {
this.backupSync.release();
}
}
// Unnamed backup for use in the global error boundary, should always be
// deleted on cms load.
deleteAnonymousBackup() {
return localForage.removeItem(getEntryBackupKey());
}
async getEntry(state, collection, slug) {
const path = selectEntryPath(collection, slug);
const label = selectFileEntryLabel(collection, slug);
const extension = selectFolderEntryExtension(collection);
const getEntryValue = async path => {
const loadedEntry = await this.implementation.getEntry(path);
let entry = createEntry(collection.get('name'), slug, loadedEntry.file.path, {
raw: loadedEntry.data,
label,
mediaFiles: [],
meta: {
path: prepareMetaPath(loadedEntry.file.path, collection)
}
});
entry = this.entryWithFormat(collection)(entry);
entry = await this.processEntry(state, collection, entry);
return entry;
};
let entryValue;
if (hasI18n(collection)) {
entryValue = await getI18nEntry(collection, extension, path, slug, getEntryValue);
} else {
entryValue = await getEntryValue(path);
}
return entryValue;
}
getMedia() {
return this.implementation.getMedia();
}
getMediaFile(path) {
return this.implementation.getMediaFile(path);
}
getMediaDisplayURL(displayURL) {
if (this.implementation.getMediaDisplayURL) {
return this.implementation.getMediaDisplayURL(displayURL);
}
const err = new Error('getMediaDisplayURL is not implemented by the current backend, but the backend returned a displayURL which was not a string!');
err.displayURL = displayURL;
return Promise.reject(err);
}
entryWithFormat(collection) {
return entry => {
const format = resolveFormat(collection, entry);
if (entry && entry.raw !== undefined) {
const data = format && attempt(format.fromFile.bind(format, entry.raw)) || {};
if (isError(data)) console.error(data);
return Object.assign(entry, {
data: isError(data) ? {} : data
});
}
return format.fromFile(entry);
};
}
async processUnpublishedEntry(collection, entryData, withMediaFiles) {
const {
slug
} = entryData;
let extension;
if (collection.get('type') === FILES) {
const file = collection.get('files').find(f => f?.get('name') === slug);
extension = extname(file.get('file'));
} else {
extension = selectFolderEntryExtension(collection);
}
const mediaFiles = [];
if (withMediaFiles) {
const nonDataFiles = entryData.diffs.filter(d => !d.path.endsWith(extension));
const files = await Promise.all(nonDataFiles.map(f => this.implementation.unpublishedEntryMediaFile(collection.get('name'), slug, f.path, f.id)));
mediaFiles.push(...files.map(f => ({
...f,
draft: true
})));
}
const dataFiles = sortBy(entryData.diffs.filter(d => d.path.endsWith(extension)), f => f.path.length);
const formatData = (data, path, newFile) => {
const entry = createEntry(collection.get('name'), slug, path, {
raw: data,
isModification: !newFile,
label: collection && selectFileEntryLabel(collection, slug),
mediaFiles,
updatedOn: entryData.updatedAt,
author: entryData.pullRequestAuthor,
status: entryData.status,
meta: {
path: prepareMetaPath(path, collection)
}
});
const entryWithFormat = this.entryWithFormat(collection)(entry);
return entryWithFormat;
};
const readAndFormatDataFile = async dataFile => {
const data = await this.implementation.unpublishedEntryDataFile(collection.get('name'), entryData.slug, dataFile.path, dataFile.id);
const entryWithFormat = formatData(data, dataFile.path, dataFile.newFile);
return entryWithFormat;
};
// if the unpublished entry has no diffs, return the original
if (dataFiles.length <= 0) {
const loadedEntry = await this.implementation.getEntry(selectEntryPath(collection, slug));
return formatData(loadedEntry.data, loadedEntry.file.path, false);
} else if (hasI18n(collection)) {
// we need to read all locales files and not just the changes
const path = selectEntryPath(collection, slug);
const i18nFiles = getI18nDataFiles(collection, extension, path, slug, dataFiles);
let entries = await Promise.all(i18nFiles.map(dataFile => readAndFormatDataFile(dataFile).catch(() => null)));
entries = entries.filter(Boolean);
const grouped = await groupEntries(collection, extension, entries);
return grouped[0];
} else {
const entryWithFormat = await readAndFormatDataFile(dataFiles[0]);
return entryWithFormat;
}
}
async unpublishedEntries(collections) {
const ids = await this.implementation.unpublishedEntries();
const entries = (await Promise.all(ids.map(async id => {
const entryData = await this.implementation.unpublishedEntry({
id
});
const collectionName = entryData.collection;
const collection = collections.find(c => c.get('name') === collectionName);
if (!collection) {
console.warn(`Missing collection '${collectionName}' for unpublished entry '${id}'`);
return null;
}
const entry = await this.processUnpublishedEntry(collection, entryData, false);
return entry;
}))).filter(Boolean);
return {
pagination: 0,
entries
};
}
async processEntry(state, collection, entry) {
const integration = selectIntegration(state.integrations, null, 'assetStore');
const mediaFolders = selectMediaFolders(state.config, collection, fromJS(entry));
if (mediaFolders.length > 0 && !integration) {
const files = await Promise.all(mediaFolders.map(folder => this.implementation.getMedia(folder)));
entry.mediaFiles = entry.mediaFiles.concat(...files);
} else {
entry.mediaFiles = entry.mediaFiles.concat(state.mediaLibrary.get('files') || []);
}
return entry;
}
async unpublishedEntry(state, collection, slug) {
const entryData = await this.implementation.unpublishedEntry({
collection: collection.get('name'),
slug
});
let entry = await this.processUnpublishedEntry(collection, entryData, true);
entry = await this.processEntry(state, collection, entry);
return entry;
}
/**
* Creates a URL using `site_url` from the config and `preview_path` from the
* entry's collection. Does not currently make a request through the backend,
* but likely will in the future.
*/
getDeploy(collection, slug, entry) {
/**
* If `site_url` is undefined or `show_preview_links` in the config is set to false, do nothing.
*/
const baseUrl = this.config.site_url;
if (!baseUrl || this.config.show_preview_links === false) {
return;
}
return {
url: previewUrlFormatter(baseUrl, collection, slug, entry, this.config.slug),
status: 'SUCCESS'
};
}
/**
* Requests a base URL from the backend for previewing a specific entry.
* Supports polling via `maxAttempts` and `interval` options, as there is
* often a delay before a preview URL is available.
*/
async getDeployPreview(collection, slug, entry, {
maxAttempts = 1,
interval = 5000,
signal
} = {}) {
/**
* If the registered backend does not provide a `getDeployPreview` method, or
* `show_preview_links` in the config is set to false, do nothing.
*/
if (!this.implementation.getDeployPreview || this.config.show_preview_links === false) {
return;
}
/**
* Poll for the deploy preview URL (defaults to 1 attempt, so no polling by
* default).
*/
let deployPreview,
count = 0;
while (!deployPreview && count < maxAttempts) {
if (signal?.aborted) {
return;
}
count++;
deployPreview = await this.implementation.getDeployPreview(collection.get('name'), slug);
if (!deployPreview) {
await new Promise(resolve => setTimeout(() => resolve(undefined), interval));
}
}
/**
* If there's no deploy preview, do nothing.
*/
if (!deployPreview) {
return;
}
return {
/**
* Create a URL using the collection `preview_path`, if provided.
*/
url: previewUrlFormatter(deployPreview.url, collection, slug, entry, this.config.slug),
/**
* Always capitalize the status for consistency.
*/
status: deployPreview.status ? deployPreview.status.toUpperCase() : ''
};
}
async persistEntry({
config,
collection,
entryDraft: draft,
assetProxies,
usedSlugs = List(),
unpublished = false,
status
}) {
const updatedEntity = await this.invokePreSaveEvent(draft.get('entry'));
let entryDraft;
if (updatedEntity.get('data') === undefined) {
entryDraft = updatedEntity && draft.setIn(['entry', 'data'], updatedEntity) || draft;
} else {
entryDraft = updatedEntity && draft.setIn(['entry'], updatedEntity) || draft;
}
const newEntry = entryDraft.getIn(['entry', 'newRecord']) || false;
const useWorkflow = selectUseWorkflow(config);
const customPath = selectCustomPath(collection, entryDraft);
let dataFile;
if (newEntry) {
if (!selectAllowNewEntries(collection)) {
throw new Error('Not allowed to create new entries in this collection');
}
const limit = collection.get('limit');
if (collection.get('type') === FOLDER && limit !== undefined && limit !== null && (await this.entrySlugsForCollectionLimit(collection, config, usedSlugs)).size >= limit) {
throw new Error(`Entry limit of ${limit} reached for collection ${collection.get('name')}`);
}
const slug = await this.generateUniqueSlug(collection, entryDraft.getIn(['entry', 'data']), config, usedSlugs, customPath);
const path = customPath || selectEntryPath(collection, slug);
dataFile = {
path,
slug,
raw: this.entryToRaw(collection, entryDraft.get('entry'))
};
updateAssetProxies(assetProxies, config, collection, entryDraft, path);
} else {
const slug = entryDraft.getIn(['entry', 'slug']);
const path = entryDraft.getIn(['entry', 'path']);
dataFile = {
path,
// for workflow entries we refresh the slug on publish
slug: customPath && !useWorkflow ? slugFromCustomPath(collection, customPath) : slug,
raw: this.entryToRaw(collection, entryDraft.get('entry')),
newPath: customPath === path ? undefined : customPath
};
}
const {
slug,
path,
newPath
} = dataFile;
let dataFiles = [dataFile];
if (hasI18n(collection)) {
const extension = selectFolderEntryExtension(collection);
dataFiles = getI18nFiles(collection, extension, entryDraft.get('entry'), draftData => this.entryToRaw(collection, draftData), path, slug, newPath);
}
const user = await this.currentUser();
const commitMessage = commitMessageFormatter(newEntry ? 'create' : 'update', config, {
collection,
slug,
path,
authorLogin: user.login,
authorName: user.name,
authorEmail: user.email
}, user.useOpenAuthoring);
const collectionName = collection.get('name');
const hasSubfolders = collection.get('nested')?.get('subfolders') !== false;
const updatedOptions = {
unpublished,
status
};
const opts = {
newEntry,
commitMessage,
collectionName,
useWorkflow,
hasSubfolders,
...updatedOptions
};
if (!useWorkflow) {
await this.invokePrePublishEvent(entryDraft.get('entry'));
}
await this.implementation.persistEntry({
dataFiles,
assets: assetProxies
}, opts);
await this.invokePostSaveEvent(entryDraft.get('entry'));
if (!useWorkflow) {
await this.invokePostPublishEvent(entryDraft.get('entry'));
}
return slug;
}
async invokeEventWithEntry(event, entry) {
const {
login,
name
} = await this.currentUser();
return await invokeEvent({
name: event,
data: {
entry,
author: {
login,
name
}
}
});
}
async invokePrePublishEvent(entry) {
await this.invokeEventWithEntry('prePublish', entry);
}
async invokePostPublishEvent(entry) {
await this.invokeEventWithEntry('postPublish', entry);
}
async invokePreUnpublishEvent(entry) {
await this.invokeEventWithEntry('preUnpublish', entry);
}
async invokePostUnpublishEvent(entry) {
await this.invokeEventWithEntry('postUnpublish', entry);
}
async invokePreSaveEvent(entry) {
return await this.invokeEventWithEntry('preSave', entry);
}
async invokePostSaveEvent(entry) {
await this.invokeEventWithEntry('postSave', entry);
}
async persistMedia(config, file) {
const user = await this.currentUser();
const options = {
commitMessage: commitMessageFormatter('uploadMedia', config, {
path: file.path,
authorLogin: user.login,
authorName: user.name,
authorEmail: user.email
}, user.useOpenAuthoring)
};
return this.implementation.persistMedia(file, options);
}
async deleteEntry(state, collection, slug) {
const config = state.config;
const path = selectEntryPath(collection, slug);
const extension = selectFolderEntryExtension(collection);
if (!selectAllowDeletion(collection)) {
throw new Error('Not allowed to delete entries in this collection');
}
const user = await this.currentUser();
const commitMessage = commitMessageFormatter('delete', config, {
collection,
slug,
path,
authorLogin: user.login,
authorName: user.name,
authorEmail: user.email
}, user.useOpenAuthoring);
const entry = selectEntry(state.entries, collection.get('name'), slug);
await this.invokePreUnpublishEvent(entry);
let paths = [path];
if (hasI18n(collection)) {
paths = getFilePaths(collection, extension, path, slug);
}
await this.implementation.deleteFiles(paths, commitMessage);
await this.invokePostUnpublishEvent(entry);
}
async deleteMedia(config, path) {
const user = await this.currentUser();
const commitMessage = commitMessageFormatter('deleteMedia', config, {
path,
authorLogin: user.login,
authorName: user.name,
authorEmail: user.email
}, user.useOpenAuthoring);
return this.implementation.deleteFiles([path], commitMessage);
}
persistUnpublishedEntry(args) {
return this.persistEntry({
...args,
unpublished: true
});
}
updateUnpublishedEntryStatus(collection, slug, newStatus) {
return this.implementation.updateUnpublishedEntryStatus(collection, slug, newStatus);
}
async publishUnpublishedEntry(entry) {
const collection = entry.get('collection');
const slug = entry.get('slug');
await this.invokePrePublishEvent(entry);
await this.implementation.publishUnpublishedEntry(collection, slug);
await this.invokePostPublishEvent(entry);
}
deleteUnpublishedEntry(collection, slug) {
return this.implementation.deleteUnpublishedEntry(collection, slug);
}
entryToRaw(collection, entry) {
const format = resolveFormat(collection, entry.toJS());
const fieldsOrder = this.fieldsOrder(collection, entry);
const fieldsComments = selectFieldsComments(collection, entry);
let content = format.toFile(entry.get('data').toJS(), fieldsOrder, fieldsComments);
if (content.slice(-1) != '\n') {
// add the EOL if it does not exist.
content += '\n';
}
return content;
}
fieldsOrder(collection, entry) {
const fields = collection.get('fields');
if (fields) {
return collection.get('fields').map(f => f.get('name')).toArray();
}
const files = collection.get('files');
const file = (files || List()).filter(f => f.get('name') === entry.get('slug')).get(0);
if (file == null) {
throw new Error(`No file found for ${entry.get('slug')} in ${collection.get('name')}`);
}
return file.get('fields').map(f => f.get('name')).toArray();
}
filterEntries(collection, filterRule) {
return collection.entries.filter(entry => {
const fieldValue = entry.data[filterRule.get('field')];
if (Array.isArray(fieldValue)) {
return fieldValue.includes(filterRule.get('value'));
}
return fieldValue === filterRule.get('value');
});
}
}
export function resolveBackend(config) {
if (!config.backend.name) {
throw new Error('No backend defined in configuration');
}
const {
name
} = config.backend;
const authStore = new LocalStorageAuthStore();
const backend = getBackend(name);
if (!backend) {
throw new Error(`Backend not found: ${name}`);
} else {
return new Backend(backend, {
backendName: name,
authStore,
config
});
}
}
export const currentBackend = function () {
let backend;
return config => {
if (backend) {
return backend;
}
return backend = resolveBackend(config);
};
}();