799c7e6936
Co-authored-by: Denys Konovalov <kontakt@denyskon.de> Co-authored-by: Mathieu COSYNS <64072917+Mathieu-COSYNS@users.noreply.github.com>
1440 lines
42 KiB
TypeScript
1440 lines
42 KiB
TypeScript
import * as fuzzy from 'fuzzy';
|
|
import attempt from 'lodash/attempt';
|
|
import flatten from 'lodash/flatten';
|
|
import get from 'lodash/get';
|
|
import isError from 'lodash/isError';
|
|
import uniq from 'lodash/uniq';
|
|
import { dirname, extname } from 'path';
|
|
|
|
import { DRAFT_MEDIA_FILES } from './constants/mediaLibrary';
|
|
import { WorkflowStatus, workflowStatusFromString } from './constants/publishModes';
|
|
import { formatExtensions, resolveFormat } from './formats/formats';
|
|
import { commitMessageFormatter, slugFormatter } from './lib/formatters';
|
|
import {
|
|
I18N_STRUCTURE_MULTIPLE_FILES,
|
|
I18N_STRUCTURE_MULTIPLE_FOLDERS,
|
|
formatI18nBackup,
|
|
getFilePaths,
|
|
getI18nBackup,
|
|
getI18nDataFiles,
|
|
getI18nEntry,
|
|
getI18nFiles,
|
|
getI18nFilesDepth,
|
|
getI18nInfo,
|
|
groupEntries,
|
|
hasI18n,
|
|
} from './lib/i18n';
|
|
import { getBackend, invokeEvent } from './lib/registry';
|
|
import { joinUrlPath, sanitizeChar } from './lib/urlHelper';
|
|
import {
|
|
CURSOR_COMPATIBILITY_SYMBOL,
|
|
Cursor,
|
|
asyncLock,
|
|
blobToFileObj,
|
|
getPathDepth,
|
|
localForage,
|
|
} from './lib/util';
|
|
import { EDITORIAL_WORKFLOW_ERROR } from './lib/util/EditorialWorkflowError';
|
|
import { getEntryBackupKey } from './lib/util/backup.util';
|
|
import {
|
|
getFields,
|
|
selectAllowDeletion,
|
|
selectAllowNewEntries,
|
|
selectEntryPath,
|
|
selectEntrySlug,
|
|
selectFieldsComments,
|
|
selectFileEntryLabel,
|
|
selectFolderEntryExtension,
|
|
selectInferredField,
|
|
selectMediaFolders,
|
|
} from './lib/util/collection.util';
|
|
import filterEntries from './lib/util/filter.util';
|
|
import { selectMediaFilePublicPath } from './lib/util/media.util';
|
|
import { selectCustomPath, slugFromCustomPath } from './lib/util/nested.util';
|
|
import { isNotNullish, isNullish } from './lib/util/null.util';
|
|
import { fileSearch, sortByScore } from './lib/util/search.util';
|
|
import set from './lib/util/set.util';
|
|
import { dateParsers, expandPath, extractTemplateVars } from './lib/widgets/stringTemplate';
|
|
import { getUseWorkflow } from './reducers/selectors/config';
|
|
import createEntry from './valueObjects/createEntry';
|
|
|
|
import type {
|
|
BackendClass,
|
|
BackendInitializer,
|
|
BackupEntry,
|
|
BaseField,
|
|
CollectionFile,
|
|
CollectionWithDefaults,
|
|
CollectionsWithDefaults,
|
|
ConfigWithDefaults,
|
|
Credentials,
|
|
DataFile,
|
|
DisplayURL,
|
|
Entry,
|
|
EntryData,
|
|
EventData,
|
|
FilterRule,
|
|
FolderCollectionWithDefaults,
|
|
I18nInfo,
|
|
ImplementationEntry,
|
|
MediaField,
|
|
ObjectValue,
|
|
PersistArgs,
|
|
SearchQueryResponse,
|
|
SearchResponse,
|
|
UnknownField,
|
|
UnpublishedEntry,
|
|
UnpublishedEntryDiff,
|
|
User,
|
|
ValueOrNestedValue,
|
|
} from './interface';
|
|
import type { AsyncLock } from './lib/util';
|
|
import type { RootState } from './store';
|
|
import type AssetProxy from './valueObjects/AssetProxy';
|
|
|
|
const LIST_ALL_ENTRIES_CACHE_TIME = 5000;
|
|
|
|
function updatePath(entryPath: string, assetPath: string): string | null {
|
|
const pathDir = dirname(entryPath);
|
|
|
|
const pathParts = assetPath.split(DRAFT_MEDIA_FILES);
|
|
const restOfPath = pathParts.length > 1 ? pathParts[1] : null;
|
|
if (restOfPath === null) {
|
|
return null;
|
|
}
|
|
|
|
return joinUrlPath(pathDir, restOfPath).replace(/\/\//g, '');
|
|
}
|
|
|
|
function updateAssetFields(data: ValueOrNestedValue, path: string): ValueOrNestedValue {
|
|
if (
|
|
isNullish(data) ||
|
|
typeof data === 'number' ||
|
|
typeof data === 'boolean' ||
|
|
data instanceof Date
|
|
) {
|
|
return data;
|
|
}
|
|
|
|
if (Array.isArray(data)) {
|
|
return data.map(child => updateAssetFields(child, path));
|
|
}
|
|
|
|
if (typeof data === 'object') {
|
|
return Object.keys(data).reduce((acc, key) => {
|
|
acc[key] = updateAssetFields(data[key], path);
|
|
|
|
return acc;
|
|
}, {} as ObjectValue);
|
|
}
|
|
|
|
const newPath = updatePath(path, data);
|
|
if (!newPath) {
|
|
return data;
|
|
}
|
|
|
|
return newPath;
|
|
}
|
|
|
|
function updateAssetProxies(assetProxies: AssetProxy[], path: string) {
|
|
assetProxies.forEach(asset => {
|
|
const newPath = updatePath(path, asset.path);
|
|
if (newPath) {
|
|
asset.path = newPath;
|
|
}
|
|
});
|
|
}
|
|
|
|
export class LocalStorageAuthStore {
|
|
storageKey = 'static-cms-user';
|
|
|
|
retrieve() {
|
|
const data = window.localStorage.getItem(this.storageKey);
|
|
return data && JSON.parse(data);
|
|
}
|
|
|
|
store(userData: unknown) {
|
|
window.localStorage.setItem(this.storageKey, JSON.stringify(userData));
|
|
}
|
|
|
|
logout() {
|
|
window.localStorage.removeItem(this.storageKey);
|
|
}
|
|
}
|
|
|
|
export function getEntryField(field: string, entry: Entry): string {
|
|
const value = get(entry.data, field);
|
|
if (value) {
|
|
return String(value);
|
|
} else {
|
|
const firstFieldPart = field.split('.')[0];
|
|
if (entry[firstFieldPart as keyof Entry]) {
|
|
// allows searching using entry.slug/entry.path etc.
|
|
return String(entry[firstFieldPart as keyof Entry]);
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
}
|
|
|
|
export function extractSearchFields(searchFields: string[]) {
|
|
return (entry: Entry) =>
|
|
searchFields.reduce((acc, field) => {
|
|
const value = getEntryField(field, entry);
|
|
if (value) {
|
|
return `${acc} ${value}`;
|
|
} else {
|
|
return acc;
|
|
}
|
|
}, '');
|
|
}
|
|
|
|
export function expandSearchEntries(
|
|
entries: Entry[],
|
|
searchFields: string[],
|
|
): (Entry & {
|
|
field: string;
|
|
})[] {
|
|
// 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;
|
|
}, [] as string[]);
|
|
|
|
for (let i = 0; i < expandedFields.length; i++) {
|
|
acc.push({ ...e, field: expandedFields[i] });
|
|
}
|
|
|
|
return acc;
|
|
},
|
|
[] as (Entry & { field: string })[],
|
|
);
|
|
|
|
return expandedEntries;
|
|
}
|
|
|
|
export function mergeExpandedEntries(entries: (Entry & { field: string })[]): Entry[] {
|
|
// merge the search results by slug and only keep data that matched the search
|
|
const fields = entries.map(f => f.field);
|
|
const arrayPaths: Record<string, Set<string>> = {};
|
|
|
|
const merged = entries.reduce(
|
|
(acc, e) => {
|
|
if (!acc[e.slug]) {
|
|
const { field: _field, ...rest } = e;
|
|
acc[e.slug] = rest;
|
|
arrayPaths[e.slug] = new Set();
|
|
}
|
|
|
|
const nestedFields = e.field.split('.');
|
|
let value: ValueOrNestedValue = acc[e.slug].data;
|
|
for (let i = 0; i < nestedFields.length; i++) {
|
|
if (isNotNullish(value)) {
|
|
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;
|
|
},
|
|
{} as Record<string, Entry>,
|
|
);
|
|
|
|
// this keeps the search score sorting order designated by the order in entries
|
|
// and filters non matching items
|
|
return Object.keys(merged).map(slug => {
|
|
let data = merged[slug].data ?? {};
|
|
for (const path of arrayPaths[slug]) {
|
|
const array = get(data, path) as unknown[];
|
|
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;
|
|
});
|
|
|
|
data = set(data, path, filtered);
|
|
}
|
|
|
|
return {
|
|
...merged[slug],
|
|
data,
|
|
};
|
|
});
|
|
}
|
|
|
|
interface AuthStore {
|
|
retrieve: () => User;
|
|
store: (user: User) => void;
|
|
logout: () => void;
|
|
}
|
|
|
|
interface BackendOptions<EF extends BaseField> {
|
|
backendName: string;
|
|
config: ConfigWithDefaults<EF>;
|
|
authStore?: AuthStore;
|
|
}
|
|
|
|
export interface MediaFile {
|
|
name: string;
|
|
id: string;
|
|
size?: number;
|
|
displayURL?: DisplayURL;
|
|
path: string;
|
|
draft?: boolean;
|
|
url?: string;
|
|
file?: File;
|
|
field?: MediaField;
|
|
queryOrder?: unknown;
|
|
isViewableImage?: boolean;
|
|
type?: string;
|
|
isDirectory?: boolean;
|
|
}
|
|
|
|
function selectHasMetaPath(
|
|
collection: CollectionWithDefaults,
|
|
): collection is FolderCollectionWithDefaults {
|
|
return Boolean('folder' in collection && collection.meta?.path);
|
|
}
|
|
|
|
function prepareMetaPath(path: string, collection: CollectionWithDefaults) {
|
|
if (!selectHasMetaPath(collection)) {
|
|
return path;
|
|
}
|
|
const dir = dirname(path);
|
|
return dir.slice(collection.folder!.length + 1) || '/';
|
|
}
|
|
|
|
function collectionDepth<EF extends BaseField>(collection: CollectionWithDefaults<EF>) {
|
|
let depth;
|
|
depth =
|
|
('nested' in collection && collection.nested?.depth) || getPathDepth(collection.path ?? '');
|
|
|
|
if (hasI18n(collection)) {
|
|
depth = getI18nFilesDepth(collection, depth);
|
|
}
|
|
|
|
return depth;
|
|
}
|
|
|
|
function i18nRuleString(ruleString: string, { default_locale, structure }: I18nInfo): string {
|
|
if (structure === I18N_STRUCTURE_MULTIPLE_FOLDERS) {
|
|
return `${default_locale}\\/${ruleString}`;
|
|
}
|
|
|
|
if (structure === I18N_STRUCTURE_MULTIPLE_FILES) {
|
|
return `${ruleString}\\.${default_locale}\\..*`;
|
|
}
|
|
|
|
return ruleString;
|
|
}
|
|
|
|
function collectionRegex<EF extends BaseField>(
|
|
collection: CollectionWithDefaults<EF>,
|
|
): RegExp | undefined {
|
|
let ruleString = '';
|
|
|
|
if ('folder' in collection && collection.path) {
|
|
ruleString = `${collection.folder}/${collection.path}`.replace(/{{.*}}/gm, '(.*)');
|
|
}
|
|
|
|
if (hasI18n(collection)) {
|
|
ruleString = i18nRuleString(ruleString, getI18nInfo(collection));
|
|
}
|
|
|
|
return ruleString ? new RegExp(ruleString) : undefined;
|
|
}
|
|
|
|
export class Backend<EF extends BaseField = UnknownField, BC extends BackendClass = BackendClass> {
|
|
implementation: BC;
|
|
backendName: string;
|
|
config: ConfigWithDefaults<EF>;
|
|
authStore?: AuthStore;
|
|
user?: User | null;
|
|
backupSync: AsyncLock;
|
|
|
|
constructor(
|
|
implementation: BackendInitializer<EF>,
|
|
{ backendName, authStore, config }: BackendOptions<EF>,
|
|
) {
|
|
// 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: getUseWorkflow(this.config as ConfigWithDefaults),
|
|
updateUserCredentials: this.updateUserCredentials,
|
|
initialWorkflowStatus: WorkflowStatus.DRAFT,
|
|
}) as BC;
|
|
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: boolean };
|
|
api: { status: boolean; statusPage: string };
|
|
} = {
|
|
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 as User);
|
|
return this.user;
|
|
});
|
|
}
|
|
return Promise.resolve(null);
|
|
}
|
|
|
|
updateUserCredentials = (updatedCredentials: Credentials) => {
|
|
const storedUser = this.authStore!.retrieve();
|
|
if (storedUser && storedUser.backendName === this.backendName) {
|
|
this.user = { ...storedUser, ...updatedCredentials };
|
|
this.authStore!.store(this.user as User);
|
|
return this.user;
|
|
}
|
|
};
|
|
|
|
authComponent() {
|
|
return this.implementation.authComponent();
|
|
}
|
|
|
|
authenticate(credentials: Credentials) {
|
|
return this.implementation.authenticate(credentials).then(user => {
|
|
this.user = { ...user, backendName: this.backendName };
|
|
if (this.authStore) {
|
|
this.authStore.store(this.user as User);
|
|
}
|
|
return this.user;
|
|
});
|
|
}
|
|
|
|
async logout() {
|
|
try {
|
|
await this.implementation.logout();
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
} catch (e: any) {
|
|
console.warn('Error during logout', e.message);
|
|
} finally {
|
|
this.user = null;
|
|
if (this.authStore) {
|
|
this.authStore.logout();
|
|
}
|
|
}
|
|
}
|
|
|
|
getToken = () => this.implementation.getToken();
|
|
|
|
async entryExist(
|
|
collection: CollectionWithDefaults,
|
|
path: string,
|
|
slug: string,
|
|
useWorkflow: boolean,
|
|
) {
|
|
const unpublishedEntry =
|
|
useWorkflow &&
|
|
(await this.implementation
|
|
.unpublishedEntry({ collection: collection.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: CollectionWithDefaults,
|
|
entry: Entry,
|
|
config: ConfigWithDefaults,
|
|
usedSlugs: string[],
|
|
customPath: string | undefined,
|
|
) {
|
|
const slugConfig = config.slug;
|
|
let slug: string;
|
|
if (customPath) {
|
|
slug = slugFromCustomPath(collection, customPath);
|
|
} else {
|
|
const collectionFields = getFields(collection, entry.slug);
|
|
slug = slugFormatter(collection, entry.data, slugConfig, collectionFields);
|
|
}
|
|
let i = 1;
|
|
let uniqueSlug = slug;
|
|
|
|
// Check for duplicate slug in loaded entries store first before repo
|
|
while (
|
|
usedSlugs.includes(uniqueSlug) ||
|
|
(await this.entryExist(
|
|
collection,
|
|
selectEntryPath(collection, uniqueSlug) as string,
|
|
uniqueSlug,
|
|
getUseWorkflow(config),
|
|
))
|
|
) {
|
|
uniqueSlug = `${slug}${sanitizeChar(' ', slugConfig)}${i++}`;
|
|
}
|
|
return uniqueSlug;
|
|
}
|
|
|
|
processEntries<EF extends BaseField>(
|
|
loadedEntries: ImplementationEntry[],
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
): Entry[] {
|
|
const entries = loadedEntries.map(loadedEntry =>
|
|
createEntry(
|
|
collection.name,
|
|
selectEntrySlug(collection, loadedEntry.file.path),
|
|
loadedEntry.file.path,
|
|
{
|
|
raw: loadedEntry.data || '',
|
|
label: loadedEntry.file.label,
|
|
author: loadedEntry.file.author,
|
|
updatedOn: loadedEntry.file.updatedOn,
|
|
},
|
|
),
|
|
);
|
|
const formattedEntries = entries.map(this.entryWithFormat(collection, config));
|
|
// If this collection has a "filter" property, filter entries accordingly
|
|
const collectionFilter = collection.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: CollectionWithDefaults, config: ConfigWithDefaults) {
|
|
const extension = selectFolderEntryExtension(collection);
|
|
let listMethod: () => Promise<ImplementationEntry[]>;
|
|
if ('folder' in collection) {
|
|
listMethod = () => {
|
|
const depth = collectionDepth(collection);
|
|
return this.implementation.entriesByFolder(collection.folder as string, extension, depth);
|
|
};
|
|
} else {
|
|
const files = collection.files.map(collectionFile => ({
|
|
path: collectionFile!.file,
|
|
label: collectionFile!.label,
|
|
}));
|
|
listMethod = () => this.implementation.entriesByFiles(files);
|
|
}
|
|
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, config),
|
|
pagination: cursor.meta?.page,
|
|
cursor,
|
|
};
|
|
}
|
|
|
|
backendPromise: Record<string, { expires: number; data?: Entry[]; promise?: Promise<Entry[]> }> =
|
|
{};
|
|
|
|
async listAllEntriesExecutor<EF extends BaseField>(
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
): Promise<Entry[]> {
|
|
if ('folder' in collection && collection.folder && this.implementation.allEntriesByFolder) {
|
|
const depth = collectionDepth(collection);
|
|
const extension = selectFolderEntryExtension(collection);
|
|
return this.implementation
|
|
.allEntriesByFolder(
|
|
collection.folder as string,
|
|
extension,
|
|
depth,
|
|
collectionRegex(collection),
|
|
)
|
|
.then(entries => this.processEntries(entries, collection, config));
|
|
}
|
|
|
|
const response = await this.listEntries(
|
|
collection as CollectionWithDefaults,
|
|
config as ConfigWithDefaults,
|
|
);
|
|
const { entries } = response;
|
|
let { cursor } = response;
|
|
while (cursor && cursor.actions?.has('next')) {
|
|
const { entries: newEntries, cursor: newCursor } = await this.traverseCursor(
|
|
cursor,
|
|
'next',
|
|
config as ConfigWithDefaults,
|
|
);
|
|
entries.push(...newEntries);
|
|
cursor = newCursor;
|
|
}
|
|
return entries;
|
|
}
|
|
|
|
// 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<EF extends BaseField>(
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
): Promise<Entry[]> {
|
|
const now = new Date().getTime();
|
|
if (collection.name in this.backendPromise) {
|
|
const cachedRequest = this.backendPromise[collection.name];
|
|
if (cachedRequest && cachedRequest.expires >= now) {
|
|
if (cachedRequest.data) {
|
|
return Promise.resolve(cachedRequest.data);
|
|
}
|
|
|
|
if (cachedRequest.promise) {
|
|
return cachedRequest.promise;
|
|
}
|
|
}
|
|
|
|
delete this.backendPromise[collection.name];
|
|
}
|
|
|
|
const p = new Promise<Entry[]>(resolve => {
|
|
this.listAllEntriesExecutor(collection, config).then(entries => {
|
|
const responseNow = new Date().getTime();
|
|
this.backendPromise[collection.name] = {
|
|
expires: responseNow + LIST_ALL_ENTRIES_CACHE_TIME,
|
|
data: entries,
|
|
};
|
|
resolve(entries);
|
|
});
|
|
});
|
|
|
|
this.backendPromise[collection.name] = {
|
|
expires: now + LIST_ALL_ENTRIES_CACHE_TIME,
|
|
promise: p,
|
|
};
|
|
|
|
return p;
|
|
}
|
|
|
|
printError(error: Error) {
|
|
return `\n\n${error.stack}`;
|
|
}
|
|
|
|
async search(
|
|
collections: CollectionWithDefaults[],
|
|
searchTerm: string,
|
|
config: ConfigWithDefaults,
|
|
): Promise<SearchResponse> {
|
|
// Perform a local search by requesting all entries. For each
|
|
// collection, load it, search, and call onCollectionResults with
|
|
// its results.
|
|
const errors: Error[] = [];
|
|
const collectionEntriesRequests = collections
|
|
.map(async collection => {
|
|
const summary = collection.summary ?? '';
|
|
const summaryFields = extractTemplateVars(summary);
|
|
|
|
// TODO: pass search fields in as an argument
|
|
let searchFields: (string | null | undefined)[] = [];
|
|
|
|
if ('files' in collection) {
|
|
collection.files.forEach(f => {
|
|
const topLevelFields = f!.fields.map(f => f!.name);
|
|
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) as string[];
|
|
const collectionEntries = await this.listAllEntries(collection, config);
|
|
return fuzzy.filter(searchTerm, collectionEntries, {
|
|
extract: extractSearchFields(uniq(filteredSearchFields)),
|
|
});
|
|
})
|
|
.map(p =>
|
|
p.catch(err => {
|
|
errors.push(err);
|
|
return [] as fuzzy.FilterResult<Entry>[];
|
|
}),
|
|
);
|
|
|
|
const entries = await Promise.all(collectionEntriesRequests).then(arrays => flatten(arrays));
|
|
|
|
if (errors.length > 0) {
|
|
throw new Error(
|
|
`Errors occurred while searching entries locally!${errors.map(this.printError)}`,
|
|
);
|
|
}
|
|
|
|
const hits = entries
|
|
.filter(({ score }: fuzzy.FilterResult<Entry>) => score > 3)
|
|
.sort(sortByScore)
|
|
.map((f: fuzzy.FilterResult<Entry>) => f.original);
|
|
return { entries: hits, pagination: 1 };
|
|
}
|
|
|
|
async query<EF extends BaseField>(
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
searchFields: string[],
|
|
searchTerm: string,
|
|
file?: string,
|
|
limit?: number,
|
|
): Promise<SearchQueryResponse> {
|
|
const entries = await this.listAllEntries(
|
|
collection as CollectionWithDefaults,
|
|
config as ConfigWithDefaults,
|
|
);
|
|
if (file) {
|
|
let hits = fileSearch(
|
|
entries.find(e => e.slug === file),
|
|
searchFields,
|
|
searchTerm,
|
|
);
|
|
if (limit !== undefined && limit > 0) {
|
|
hits = hits.slice(0, limit);
|
|
}
|
|
|
|
return { query: searchTerm, hits };
|
|
}
|
|
|
|
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: Cursor,
|
|
action: string,
|
|
config: ConfigWithDefaults,
|
|
): Promise<{ entries: Entry[]; cursor: Cursor }> {
|
|
const [data, unwrappedCursor] = cursor.unwrapData();
|
|
// TODO: stop assuming all cursors are for collections
|
|
const collection = data.collection as CollectionWithDefaults;
|
|
return this.implementation.traverseCursor!(unwrappedCursor, action).then(
|
|
async ({ entries, cursor: newCursor }) => ({
|
|
entries: this.processEntries(entries, collection, config),
|
|
cursor: Cursor.create(newCursor).wrapData({
|
|
cursorType: 'collectionEntries',
|
|
collection,
|
|
}),
|
|
}),
|
|
);
|
|
}
|
|
|
|
async getLocalDraftBackup(
|
|
collection: CollectionWithDefaults,
|
|
config: ConfigWithDefaults,
|
|
slug: string,
|
|
): Promise<{ entry: Entry | null }> {
|
|
const key = getEntryBackupKey(collection.name, slug);
|
|
const backup = await localForage.getItem<BackupEntry>(key);
|
|
if (!backup || !backup.raw.trim()) {
|
|
return { entry: null };
|
|
}
|
|
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: string) => {
|
|
return this.entryWithFormat(
|
|
collection,
|
|
config,
|
|
)(
|
|
createEntry(collection.name, slug, path, {
|
|
raw,
|
|
label,
|
|
mediaFiles,
|
|
}),
|
|
);
|
|
};
|
|
|
|
const entry: Entry = formatRawData(raw);
|
|
if (hasI18n(collection) && backup.i18n) {
|
|
const i18n = formatI18nBackup(backup.i18n, formatRawData);
|
|
entry.i18n = i18n;
|
|
}
|
|
|
|
return { entry };
|
|
}
|
|
|
|
async persistLocalDraftBackup(
|
|
entry: Entry,
|
|
collection: CollectionWithDefaults,
|
|
config: ConfigWithDefaults,
|
|
) {
|
|
try {
|
|
await this.backupSync.acquire();
|
|
const key = getEntryBackupKey(collection.name, entry.slug);
|
|
const raw = this.entryToRaw(collection, entry, config);
|
|
|
|
if (!raw.trim()) {
|
|
return;
|
|
}
|
|
|
|
const mediaFiles = await Promise.all<MediaFile>(
|
|
entry.mediaFiles.map(async (file: MediaFile) => {
|
|
// make sure to serialize the file
|
|
if (file.url?.startsWith('blob:')) {
|
|
const blob = await fetch(file.url as string).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, config),
|
|
);
|
|
}
|
|
|
|
await localForage.setItem<BackupEntry>(key, {
|
|
raw,
|
|
path: entry.path,
|
|
mediaFiles,
|
|
...(i18n && { i18n }),
|
|
});
|
|
const result = await localForage.setItem(getEntryBackupKey(), raw);
|
|
return result;
|
|
} catch (e) {
|
|
console.warn('[StaticCMS] persistLocalDraftBackup', e);
|
|
} finally {
|
|
this.backupSync.release();
|
|
}
|
|
}
|
|
|
|
async deleteLocalDraftBackup(collection: CollectionWithDefaults, slug: string) {
|
|
try {
|
|
await this.backupSync.acquire();
|
|
await localForage.removeItem(getEntryBackupKey(collection.name, slug));
|
|
// delete new entry backup if not deleted
|
|
slug && (await localForage.removeItem(getEntryBackupKey(collection.name)));
|
|
const result = await this.deleteAnonymousBackup();
|
|
return result;
|
|
} catch (e) {
|
|
console.warn('[StaticCMS] 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<EF extends BaseField>(
|
|
state: RootState<EF>,
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
slug: string,
|
|
) {
|
|
const path = selectEntryPath(collection, slug) as string;
|
|
const label = selectFileEntryLabel(collection, slug);
|
|
const extension = selectFolderEntryExtension(collection);
|
|
|
|
const getEntryValue = async (path: string) => {
|
|
const loadedEntry = await this.implementation.getEntry(path);
|
|
let entry = createEntry(collection.name, slug, loadedEntry.file.path, {
|
|
raw: loadedEntry.data,
|
|
label,
|
|
mediaFiles: [],
|
|
});
|
|
|
|
entry = this.entryWithFormat(collection, config)(entry);
|
|
entry = await this.processEntry(state, collection, entry);
|
|
|
|
return entry;
|
|
};
|
|
|
|
let entryValue: Entry;
|
|
if (hasI18n(collection)) {
|
|
entryValue = await getI18nEntry(collection, extension, path, slug, getEntryValue);
|
|
} else {
|
|
entryValue = await getEntryValue(path);
|
|
}
|
|
|
|
return entryValue;
|
|
}
|
|
|
|
getMedia(folder?: string | undefined, folderSupport?: boolean, mediaPath?: string | undefined) {
|
|
return this.implementation.getMedia(folder, folderSupport, mediaPath);
|
|
}
|
|
|
|
getMediaFile(path: string) {
|
|
return this.implementation.getMediaFile(path);
|
|
}
|
|
|
|
getMediaDisplayURL(displayURL: 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!',
|
|
) as Error & { displayURL: DisplayURL };
|
|
err.displayURL = displayURL;
|
|
return Promise.reject(err);
|
|
}
|
|
|
|
entryWithFormat<EF extends BaseField>(
|
|
collection: CollectionWithDefaults<EF>,
|
|
config: ConfigWithDefaults<EF>,
|
|
) {
|
|
return (entry: Entry): Entry => {
|
|
const format = resolveFormat(collection, entry);
|
|
if (entry && entry.raw !== undefined) {
|
|
const data =
|
|
(format &&
|
|
attempt(format.fromFile.bind(format, entry.raw, config as ConfigWithDefaults))) ||
|
|
{};
|
|
if (isError(data)) {
|
|
console.error(data);
|
|
}
|
|
|
|
return Object.assign(entry, { data: isError(data) ? {} : data });
|
|
}
|
|
|
|
return entry;
|
|
};
|
|
}
|
|
|
|
async processEntry<EF extends BaseField>(
|
|
state: RootState<EF>,
|
|
collection: CollectionWithDefaults<EF>,
|
|
entry: Entry,
|
|
) {
|
|
const configState = state.config;
|
|
if (!configState.config) {
|
|
throw new Error('Config not loaded');
|
|
}
|
|
|
|
const mediaFolders = selectMediaFolders(configState.config, collection, entry);
|
|
if (mediaFolders.length > 0) {
|
|
const files = await Promise.all(
|
|
mediaFolders.map(folder => {
|
|
const mediaPath = selectMediaFilePublicPath(
|
|
configState.config!,
|
|
collection,
|
|
'',
|
|
entry,
|
|
undefined,
|
|
);
|
|
return this.implementation.getMedia(
|
|
folder,
|
|
collection.media_library?.folder_support ?? false,
|
|
mediaPath,
|
|
);
|
|
}),
|
|
);
|
|
entry.mediaFiles = entry.mediaFiles.concat(...files);
|
|
} else {
|
|
entry.mediaFiles = entry.mediaFiles.concat(state.mediaLibrary.files || []);
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
async persistEntry({
|
|
config,
|
|
rootSlug,
|
|
collection,
|
|
entryDraft: draft,
|
|
assetProxies,
|
|
usedSlugs,
|
|
unpublished = false,
|
|
status,
|
|
}: PersistArgs) {
|
|
const modifiedData = await this.invokePreSaveEvent(draft.entry, collection);
|
|
const entryDraft = modifiedData
|
|
? {
|
|
...draft,
|
|
entry: {
|
|
...draft.entry,
|
|
data: modifiedData,
|
|
},
|
|
}
|
|
: draft;
|
|
|
|
const newEntry = entryDraft.entry.newRecord ?? false;
|
|
|
|
const useWorkflow = getUseWorkflow(config);
|
|
|
|
const customPath = selectCustomPath(draft.entry, collection, rootSlug, config.slug);
|
|
|
|
let dataFile: DataFile;
|
|
if (newEntry) {
|
|
if (!selectAllowNewEntries(collection)) {
|
|
throw new Error('Not allowed to create new entries in this collection');
|
|
}
|
|
const slug = await this.generateUniqueSlug(
|
|
collection,
|
|
entryDraft.entry,
|
|
config,
|
|
usedSlugs,
|
|
customPath,
|
|
);
|
|
const path = customPath || (selectEntryPath(collection, slug) ?? '');
|
|
|
|
entryDraft.entry.path = path;
|
|
entryDraft.entry.data = updateAssetFields(entryDraft.entry.data, path) as ObjectValue;
|
|
updateAssetProxies(assetProxies, path);
|
|
|
|
dataFile = {
|
|
path,
|
|
slug,
|
|
raw: this.entryToRaw(collection, entryDraft.entry, config),
|
|
};
|
|
} else {
|
|
const slug = entryDraft.entry.slug;
|
|
dataFile = {
|
|
path: entryDraft.entry.path,
|
|
// for workflow entries we refresh the slug on publish
|
|
slug: customPath && !useWorkflow ? slugFromCustomPath(collection, customPath) : slug,
|
|
raw: this.entryToRaw(collection, entryDraft.entry, config),
|
|
newPath: customPath,
|
|
};
|
|
}
|
|
|
|
const { slug, path, newPath } = dataFile;
|
|
|
|
let dataFiles = [dataFile];
|
|
if (hasI18n(collection)) {
|
|
const extension = selectFolderEntryExtension(collection);
|
|
dataFiles = getI18nFiles(
|
|
collection,
|
|
extension,
|
|
entryDraft.entry,
|
|
(draftData: Entry) => this.entryToRaw(collection, draftData, config),
|
|
path,
|
|
slug,
|
|
newPath,
|
|
);
|
|
}
|
|
|
|
const user = (await this.currentUser()) as User;
|
|
const commitMessage = commitMessageFormatter(
|
|
newEntry ? 'create' : 'update',
|
|
config,
|
|
{
|
|
collection,
|
|
slug,
|
|
path,
|
|
authorLogin: user.login,
|
|
authorName: user.name,
|
|
},
|
|
user.useOpenAuthoring,
|
|
);
|
|
|
|
const collectionName = collection.name;
|
|
|
|
const opts = {
|
|
newEntry,
|
|
commitMessage,
|
|
collectionName,
|
|
useWorkflow,
|
|
unpublished,
|
|
status,
|
|
};
|
|
|
|
if (!useWorkflow) {
|
|
await this.invokePrePublishEvent(entryDraft.entry, collection);
|
|
}
|
|
|
|
await this.implementation.persistEntry(
|
|
{
|
|
dataFiles,
|
|
assets: assetProxies,
|
|
},
|
|
opts,
|
|
);
|
|
|
|
await this.invokePostSaveEvent(entryDraft.entry, collection);
|
|
|
|
if (!useWorkflow) {
|
|
await this.invokePostPublishEvent(entryDraft.entry, collection);
|
|
}
|
|
|
|
return slug;
|
|
}
|
|
|
|
async getEventData(entry: Entry): Promise<EventData> {
|
|
const { login, name = '' } = (await this.currentUser()) as User;
|
|
return { entry, author: { login, name } };
|
|
}
|
|
|
|
async invokePrePublishEvent(entry: Entry, collection: CollectionWithDefaults) {
|
|
const eventData = await this.getEventData(entry);
|
|
return await invokeEvent({ name: 'prePublish', collection: collection.name, data: eventData });
|
|
}
|
|
|
|
async invokePostPublishEvent(entry: Entry, collection: CollectionWithDefaults) {
|
|
const eventData = await this.getEventData(entry);
|
|
return await invokeEvent({ name: 'postPublish', collection: collection.name, data: eventData });
|
|
}
|
|
|
|
async invokePreSaveEvent(entry: Entry, collection: CollectionWithDefaults): Promise<EntryData> {
|
|
const eventData = await this.getEventData(entry);
|
|
return await invokeEvent({ name: 'preSave', collection: collection.name, data: eventData });
|
|
}
|
|
|
|
async invokePostSaveEvent(entry: Entry, collection: CollectionWithDefaults): Promise<void> {
|
|
const eventData = await this.getEventData(entry);
|
|
await invokeEvent({ name: 'postSave', collection: collection.name, data: eventData });
|
|
}
|
|
|
|
async persistMedia(config: ConfigWithDefaults, file: AssetProxy) {
|
|
const user = (await this.currentUser()) as User;
|
|
const options = {
|
|
commitMessage: commitMessageFormatter(
|
|
'uploadMedia',
|
|
config,
|
|
{
|
|
path: file.path,
|
|
authorLogin: user.login,
|
|
authorName: user.name,
|
|
},
|
|
user.useOpenAuthoring,
|
|
),
|
|
};
|
|
return this.implementation.persistMedia(file, options);
|
|
}
|
|
|
|
async deleteEntry<EF extends BaseField>(
|
|
state: RootState<EF>,
|
|
collection: CollectionWithDefaults<EF>,
|
|
slug: string,
|
|
) {
|
|
const configState = state.config;
|
|
if (!configState.config) {
|
|
throw new Error('Config not loaded');
|
|
}
|
|
|
|
const path = selectEntryPath(collection, slug) as string;
|
|
const extension = selectFolderEntryExtension(collection) as string;
|
|
|
|
if (!selectAllowDeletion(collection)) {
|
|
throw new Error('Not allowed to delete entries in this collection');
|
|
}
|
|
|
|
const user = (await this.currentUser()) as User;
|
|
const commitMessage = commitMessageFormatter(
|
|
'delete',
|
|
configState.config,
|
|
{
|
|
collection,
|
|
slug,
|
|
path,
|
|
authorLogin: user.login,
|
|
authorName: user.name,
|
|
},
|
|
user.useOpenAuthoring,
|
|
);
|
|
|
|
let paths = [path];
|
|
if (hasI18n(collection)) {
|
|
paths = getFilePaths(collection, extension, path, slug);
|
|
}
|
|
await this.implementation.deleteFiles(paths, commitMessage);
|
|
}
|
|
|
|
async deleteMedia(config: ConfigWithDefaults, path: string) {
|
|
const user = (await this.currentUser()) as User;
|
|
const commitMessage = commitMessageFormatter(
|
|
'deleteMedia',
|
|
config,
|
|
{
|
|
path,
|
|
authorLogin: user.login,
|
|
authorName: user.name,
|
|
},
|
|
user.useOpenAuthoring,
|
|
);
|
|
return this.implementation.deleteFiles([path], commitMessage);
|
|
}
|
|
|
|
entryToRaw(collection: CollectionWithDefaults, entry: Entry, config: ConfigWithDefaults): string {
|
|
const format = resolveFormat(collection, entry);
|
|
const fieldsOrder = this.fieldsOrder(collection, entry);
|
|
const fieldsComments = selectFieldsComments(collection, entry);
|
|
return format ? format.toFile(entry.data ?? {}, config, fieldsOrder, fieldsComments) : '';
|
|
}
|
|
|
|
fieldsOrder(collection: CollectionWithDefaults, entry: Entry) {
|
|
if ('fields' in collection) {
|
|
return collection.fields?.map(f => f!.name) ?? [];
|
|
}
|
|
|
|
const files = collection.files ?? [];
|
|
const file: CollectionFile | null = files.filter(f => f!.name === entry.slug)?.[0] ?? null;
|
|
|
|
if (file == null) {
|
|
throw new Error(`No file found for ${entry.slug} in ${collection.name}`);
|
|
}
|
|
return file.fields.map(f => f.name);
|
|
}
|
|
|
|
filterEntries(collection: { entries: Entry[] }, filterRule: FilterRule | FilterRule[]) {
|
|
return filterEntries(collection.entries, filterRule, undefined);
|
|
}
|
|
|
|
/**
|
|
* Editorial Workflows
|
|
*/
|
|
async processUnpublishedEntry(
|
|
collection: CollectionWithDefaults,
|
|
config: ConfigWithDefaults,
|
|
entryData: UnpublishedEntry,
|
|
withMediaFiles: boolean,
|
|
) {
|
|
const { slug, openAuthoring } = entryData;
|
|
let extension: string;
|
|
if ('files' in collection) {
|
|
const file = collection.files.find(f => f?.name === slug);
|
|
extension = file ? extname(file.file) : formatExtensions['json'];
|
|
} else {
|
|
extension = selectFolderEntryExtension(collection);
|
|
}
|
|
|
|
const mediaFiles: MediaFile[] = [];
|
|
if (withMediaFiles) {
|
|
const nonDataFiles = entryData.diffs.filter(d => !d.path.endsWith(extension));
|
|
const files = await Promise.all(
|
|
nonDataFiles.map(f =>
|
|
this.implementation!.unpublishedEntryMediaFile(collection.name, slug, f.path, f.id),
|
|
),
|
|
);
|
|
mediaFiles.push(...files.map(f => ({ ...f, draft: true })));
|
|
}
|
|
|
|
const dataFiles = entryData.diffs.filter(d => d.path.endsWith(extension));
|
|
dataFiles.sort((a, b) => a.path.length - b.path.length);
|
|
|
|
const formatData = (data: string, path: string, newFile: boolean) => {
|
|
const entry = createEntry(collection.name, slug, path, {
|
|
raw: data,
|
|
isModification: !newFile,
|
|
label: collection && selectFileEntryLabel(collection, slug),
|
|
mediaFiles,
|
|
updatedOn: entryData.updatedAt,
|
|
author: entryData.pullRequestAuthor,
|
|
status: workflowStatusFromString(entryData.status),
|
|
meta: { path: prepareMetaPath(path, collection) },
|
|
openAuthoring,
|
|
});
|
|
|
|
return this.entryWithFormat(collection, config)(entry);
|
|
};
|
|
|
|
const readAndFormatDataFile = async (dataFile: UnpublishedEntryDiff) => {
|
|
const data = await this.implementation.unpublishedEntryDataFile(
|
|
collection.name,
|
|
entryData.slug,
|
|
dataFile.path,
|
|
dataFile.id,
|
|
);
|
|
|
|
return formatData(data, dataFile.path, dataFile.newFile);
|
|
};
|
|
|
|
// if the unpublished entry has no diffs, return the original
|
|
if (dataFiles.length <= 0) {
|
|
const loadedEntry = await this.implementation.getEntry(
|
|
selectEntryPath(collection, slug) as string,
|
|
);
|
|
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) as string;
|
|
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 as Entry[]);
|
|
return grouped[0];
|
|
} else {
|
|
return readAndFormatDataFile(dataFiles[0]);
|
|
}
|
|
}
|
|
|
|
async unpublishedEntries(collections: CollectionsWithDefaults, config: ConfigWithDefaults) {
|
|
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 = Object.values(collections).find(c => c.name === collectionName);
|
|
if (!collection) {
|
|
console.warn(`Missing collection '${collectionName}' for unpublished entry '${id}'`);
|
|
return null;
|
|
}
|
|
|
|
return this.processUnpublishedEntry(collection, config, entryData, false);
|
|
}),
|
|
)
|
|
).filter(Boolean) as Entry[];
|
|
|
|
return { pagination: 0, entries };
|
|
}
|
|
|
|
async unpublishedEntry(
|
|
state: RootState,
|
|
collection: CollectionWithDefaults,
|
|
config: ConfigWithDefaults,
|
|
slug: string,
|
|
) {
|
|
const entryData = await this.implementation.unpublishedEntry({
|
|
collection: collection.name,
|
|
slug,
|
|
});
|
|
|
|
let entry = await this.processUnpublishedEntry(collection, config, entryData, true);
|
|
entry = await this.processEntry(state, collection, entry);
|
|
return entry;
|
|
}
|
|
|
|
persistUnpublishedEntry(args: PersistArgs) {
|
|
return this.persistEntry({ ...args, unpublished: true });
|
|
}
|
|
|
|
updateUnpublishedEntryStatus(collection: string, slug: string, newStatus: WorkflowStatus) {
|
|
return this.implementation.updateUnpublishedEntryStatus(collection, slug, newStatus);
|
|
}
|
|
|
|
deleteUnpublishedEntry(collection: string, slug: string) {
|
|
return this.implementation.deleteUnpublishedEntry(collection, slug);
|
|
}
|
|
|
|
async publishUnpublishedEntry(collection: CollectionWithDefaults, entry: Entry) {
|
|
await this.invokePrePublishEvent(entry, collection);
|
|
await this.implementation.publishUnpublishedEntry(collection.name, entry.slug);
|
|
await this.invokePostPublishEvent(entry, collection);
|
|
}
|
|
}
|
|
|
|
export function resolveBackend<EF extends BaseField>(config?: ConfigWithDefaults<EF>) {
|
|
if (!config?.backend.name) {
|
|
throw new Error('No backend defined in configuration');
|
|
}
|
|
|
|
const { name } = config.backend;
|
|
const authStore = new LocalStorageAuthStore();
|
|
|
|
const backend = getBackend<EF>(name);
|
|
if (!backend) {
|
|
throw new Error(`Backend not found: ${name}`);
|
|
} else {
|
|
return new Backend<EF, BackendClass>(backend, { backendName: name, authStore, config });
|
|
}
|
|
}
|
|
|
|
export const currentBackend = (function () {
|
|
let backend: Backend;
|
|
|
|
return <EF extends BaseField = UnknownField>(config: ConfigWithDefaults<EF>) => {
|
|
if (backend) {
|
|
return backend;
|
|
}
|
|
|
|
return (backend = resolveBackend(config) as unknown as Backend);
|
|
};
|
|
})();
|