2017-05-31 16:12:31 -04:00
|
|
|
import { attempt, isError } from 'lodash';
|
2016-12-23 16:59:48 -02:00
|
|
|
import TestRepoBackend from "./test-repo/implementation";
|
|
|
|
import GitHubBackend from "./github/implementation";
|
2017-09-05 19:30:03 -07:00
|
|
|
import GitGatewayBackend from "./git-gateway/implementation";
|
2016-12-23 16:59:48 -02:00
|
|
|
import { resolveFormat } from "../formats/formats";
|
2017-11-11 09:48:47 -05:00
|
|
|
import { selectIntegration } from '../reducers/integrations';
|
2017-10-30 20:07:54 +00:00
|
|
|
import { selectListMethod, selectEntrySlug, selectEntryPath, selectAllowNewEntries, selectAllowDeletion, selectFolderEntryExtension } from "../reducers/collections";
|
2016-12-23 16:59:48 -02:00
|
|
|
import { createEntry } from "../valueObjects/Entry";
|
2017-10-03 09:01:06 -06:00
|
|
|
import { sanitizeSlug } from "../lib/urlHelper";
|
2016-02-25 12:31:21 -08:00
|
|
|
|
2016-05-30 16:55:32 -07:00
|
|
|
class LocalStorageAuthStore {
|
2016-12-23 17:30:27 -02:00
|
|
|
storageKey = "netlify-cms-user";
|
2016-05-30 16:55:32 -07:00
|
|
|
|
|
|
|
retrieve() {
|
|
|
|
const data = window.localStorage.getItem(this.storageKey);
|
|
|
|
return data && JSON.parse(data);
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
|
|
|
|
2016-05-30 16:55:32 -07:00
|
|
|
store(userData) {
|
|
|
|
window.localStorage.setItem(this.storageKey, JSON.stringify(userData));
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
2016-11-01 14:35:20 +01:00
|
|
|
|
|
|
|
logout() {
|
|
|
|
window.localStorage.removeItem(this.storageKey);
|
|
|
|
}
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
|
|
|
|
2016-12-23 16:59:48 -02:00
|
|
|
const slugFormatter = (template = "{{slug}}", entryData) => {
|
2016-10-21 20:42:14 -02:00
|
|
|
const date = new Date();
|
2017-06-22 14:05:22 +01:00
|
|
|
|
|
|
|
const getIdentifier = (entryData) => {
|
2017-06-22 21:39:32 +01:00
|
|
|
const validIdentifierFields = ["title", "path"];
|
|
|
|
const identifiers = validIdentifierFields.map((field) =>
|
2017-06-22 21:49:31 +01:00
|
|
|
entryData.find((_, key) => key.toLowerCase().trim() === field)
|
2017-06-22 21:39:32 +01:00
|
|
|
);
|
|
|
|
|
|
|
|
const identifier = identifiers.find(ident => ident !== undefined);
|
|
|
|
|
|
|
|
if (identifier === undefined) {
|
2017-09-05 19:30:03 -07:00
|
|
|
throw new Error("Collection must have a field name that is a valid entry identifier");
|
2017-06-22 21:39:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return identifier;
|
2017-06-22 14:05:22 +01:00
|
|
|
};
|
2017-09-05 19:30:03 -07:00
|
|
|
|
2017-10-03 09:01:06 -06:00
|
|
|
const slug = template.replace(/\{\{([^\}]+)\}\}/g, (_, field) => {
|
2016-10-28 11:42:31 -02:00
|
|
|
switch (field) {
|
2016-12-23 16:59:48 -02:00
|
|
|
case "year":
|
2016-10-10 15:34:21 -03:00
|
|
|
return date.getFullYear();
|
2016-12-23 16:59:48 -02:00
|
|
|
case "month":
|
2016-10-21 20:42:14 -02:00
|
|
|
return (`0${ date.getMonth() + 1 }`).slice(-2);
|
2016-12-23 16:59:48 -02:00
|
|
|
case "day":
|
2016-10-21 20:42:14 -02:00
|
|
|
return (`0${ date.getDate() }`).slice(-2);
|
2016-12-23 16:59:48 -02:00
|
|
|
case "slug":
|
2017-09-30 17:25:05 -06:00
|
|
|
return getIdentifier(entryData).trim();
|
2016-10-10 15:34:21 -03:00
|
|
|
default:
|
2017-09-30 17:25:05 -06:00
|
|
|
return entryData.get(field, "").trim();
|
2016-10-10 15:34:21 -03:00
|
|
|
}
|
2017-10-03 09:01:06 -06:00
|
|
|
})
|
|
|
|
// Convert slug to lower-case
|
|
|
|
.toLocaleLowerCase()
|
2017-09-30 17:27:07 -06:00
|
|
|
|
|
|
|
// Replace periods and spaces with dashes.
|
2017-10-03 09:01:06 -06:00
|
|
|
.replace(/[.\s]/g, '-');
|
2017-09-30 17:27:07 -06:00
|
|
|
|
2017-10-03 09:01:06 -06:00
|
|
|
return sanitizeSlug(slug);
|
2016-10-10 15:34:21 -03:00
|
|
|
};
|
|
|
|
|
2016-02-25 12:31:21 -08:00
|
|
|
class Backend {
|
2017-08-29 13:08:15 -06:00
|
|
|
constructor(implementation, backendName, authStore = null) {
|
2016-02-25 12:31:21 -08:00
|
|
|
this.implementation = implementation;
|
2017-08-29 13:08:15 -06:00
|
|
|
this.backendName = backendName;
|
2016-02-25 12:31:21 -08:00
|
|
|
this.authStore = authStore;
|
2016-09-05 12:12:38 -03:00
|
|
|
if (this.implementation === null) {
|
2016-12-23 16:59:48 -02:00
|
|
|
throw new Error("Cannot instantiate a Backend with no implementation");
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
currentUser() {
|
|
|
|
if (this.user) { return this.user; }
|
2016-06-05 01:52:18 -07:00
|
|
|
const stored = this.authStore && this.authStore.retrieve();
|
2017-08-29 13:08:15 -06:00
|
|
|
if (stored && stored.backendName === this.backendName) {
|
2017-08-29 13:45:05 -06:00
|
|
|
return Promise.resolve(this.implementation.restoreUser(stored)).then((user) => {
|
2017-08-29 13:08:15 -06:00
|
|
|
const newUser = {...user, backendName: this.backendName};
|
|
|
|
// return confirmed/rehydrated user object instead of stored
|
|
|
|
this.authStore.store(newUser);
|
|
|
|
return newUser;
|
2017-08-27 20:12:54 -06:00
|
|
|
});
|
2016-06-05 01:52:18 -07:00
|
|
|
}
|
2016-12-23 16:59:48 -02:00
|
|
|
return Promise.resolve(null);
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
authComponent() {
|
|
|
|
return this.implementation.authComponent();
|
|
|
|
}
|
|
|
|
|
2016-02-25 20:40:35 -08:00
|
|
|
authenticate(credentials) {
|
2016-05-30 16:55:32 -07:00
|
|
|
return this.implementation.authenticate(credentials).then((user) => {
|
2017-08-29 13:08:15 -06:00
|
|
|
const newUser = {...user, backendName: this.backendName};
|
|
|
|
if (this.authStore) { this.authStore.store(newUser); }
|
|
|
|
return newUser;
|
2016-05-30 16:55:32 -07:00
|
|
|
});
|
2016-02-25 20:40:35 -08:00
|
|
|
}
|
|
|
|
|
2016-11-01 14:35:20 +01:00
|
|
|
logout() {
|
2017-09-05 19:30:03 -07:00
|
|
|
return Promise.resolve(this.implementation.logout()).then(() => {
|
|
|
|
if (this.authStore) {
|
|
|
|
this.authStore.logout();
|
|
|
|
}
|
|
|
|
});
|
2016-11-01 14:35:20 +01:00
|
|
|
}
|
|
|
|
|
2017-01-10 22:23:22 -02:00
|
|
|
getToken = () => this.implementation.getToken();
|
|
|
|
|
2016-10-21 20:42:14 -02:00
|
|
|
listEntries(collection) {
|
2016-11-11 17:54:58 -02:00
|
|
|
const listMethod = this.implementation[selectListMethod(collection)];
|
2017-04-14 19:19:45 +01:00
|
|
|
const extension = selectFolderEntryExtension(collection);
|
2017-05-05 17:25:59 +01:00
|
|
|
const collectionFilter = collection.get('filter');
|
2017-04-14 19:19:45 +01:00
|
|
|
return listMethod.call(this.implementation, collection, extension)
|
2016-10-21 20:42:14 -02:00
|
|
|
.then(loadedEntries => (
|
2016-10-27 14:23:36 +02:00
|
|
|
loadedEntries.map(loadedEntry => createEntry(
|
2016-12-23 16:59:48 -02:00
|
|
|
collection.get("name"),
|
2016-11-11 17:54:58 -02:00
|
|
|
selectEntrySlug(collection, loadedEntry.file.path),
|
2016-10-27 14:23:36 +02:00
|
|
|
loadedEntry.file.path,
|
2017-05-31 16:12:31 -04:00
|
|
|
{ raw: loadedEntry.data || '', label: loadedEntry.file.label }
|
2016-10-27 14:23:36 +02:00
|
|
|
))
|
2016-10-21 20:42:14 -02:00
|
|
|
))
|
|
|
|
.then(entries => (
|
|
|
|
{
|
|
|
|
entries: entries.map(this.entryWithFormat(collection)),
|
|
|
|
}
|
2017-05-05 17:25:59 +01:00
|
|
|
))
|
|
|
|
// If this collection has a "filter" property, filter entries accordingly
|
|
|
|
.then(loadedCollection => (
|
|
|
|
{
|
2017-05-25 17:24:48 +01:00
|
|
|
entries: collectionFilter ? this.filterEntries(loadedCollection, collectionFilter) : loadedCollection.entries
|
2017-05-05 17:25:59 +01:00
|
|
|
}
|
2016-10-21 20:42:14 -02:00
|
|
|
));
|
2016-02-25 20:40:35 -08:00
|
|
|
}
|
|
|
|
|
2016-10-27 13:12:18 -02:00
|
|
|
getEntry(collection, slug) {
|
2016-11-11 17:54:58 -02:00
|
|
|
return this.implementation.getEntry(collection, slug, selectEntryPath(collection, slug))
|
2016-10-27 15:33:15 +02:00
|
|
|
.then(loadedEntry => this.entryWithFormat(collection, slug)(createEntry(
|
2016-12-23 16:59:48 -02:00
|
|
|
collection.get("name"),
|
2016-10-27 14:23:36 +02:00
|
|
|
slug,
|
|
|
|
loadedEntry.file.path,
|
|
|
|
{ raw: loadedEntry.data, label: loadedEntry.file.label }
|
2016-10-27 14:45:32 +02:00
|
|
|
))
|
2016-10-27 14:23:36 +02:00
|
|
|
);
|
2016-06-05 01:52:18 -07:00
|
|
|
}
|
|
|
|
|
2017-08-14 09:00:47 -04:00
|
|
|
getMedia() {
|
|
|
|
return this.implementation.getMedia();
|
|
|
|
}
|
|
|
|
|
2016-09-06 13:04:17 -03:00
|
|
|
entryWithFormat(collectionOrEntity) {
|
2016-06-05 01:52:18 -07:00
|
|
|
return (entry) => {
|
2016-09-06 13:04:17 -03:00
|
|
|
const format = resolveFormat(collectionOrEntity, entry);
|
2017-05-31 16:12:31 -04:00
|
|
|
if (entry && entry.raw !== undefined) {
|
|
|
|
const data = (format && attempt(format.fromFile.bind(null, entry.raw))) || {};
|
2017-06-07 12:47:57 -04:00
|
|
|
if (isError(data)) console.error(data);
|
2017-05-31 16:12:31 -04:00
|
|
|
return Object.assign(entry, { data: isError(data) ? {} : data });
|
2016-06-05 01:52:18 -07:00
|
|
|
}
|
2016-10-27 14:45:32 +02:00
|
|
|
return format.fromFile(entry);
|
2016-06-05 01:52:18 -07:00
|
|
|
};
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
2016-06-06 21:53:22 -03:00
|
|
|
|
2017-11-09 13:14:45 -07:00
|
|
|
unpublishedEntries(collections) {
|
|
|
|
return this.implementation.unpublishedEntries()
|
2016-10-28 11:42:31 -02:00
|
|
|
.then(loadedEntries => loadedEntries.filter(entry => entry !== null))
|
|
|
|
.then(entries => (
|
|
|
|
entries.map((loadedEntry) => {
|
2017-03-15 18:47:18 -07:00
|
|
|
const entry = createEntry(
|
|
|
|
loadedEntry.metaData.collection,
|
|
|
|
loadedEntry.slug,
|
|
|
|
loadedEntry.file.path,
|
|
|
|
{
|
|
|
|
raw: loadedEntry.data,
|
|
|
|
isModification: loadedEntry.isModification,
|
|
|
|
}
|
|
|
|
);
|
2016-10-27 15:27:39 -02:00
|
|
|
entry.metaData = loadedEntry.metaData;
|
|
|
|
return entry;
|
|
|
|
})
|
|
|
|
))
|
2016-10-28 11:42:31 -02:00
|
|
|
.then(entries => ({
|
|
|
|
pagination: 0,
|
2017-11-09 13:14:45 -07:00
|
|
|
entries: entries.map(entry => {
|
|
|
|
const collection = collections.get(entry.collection);
|
|
|
|
return this.entryWithFormat(collection)(entry);
|
|
|
|
}),
|
2016-10-28 11:42:31 -02:00
|
|
|
}));
|
2016-09-06 13:04:17 -03:00
|
|
|
}
|
|
|
|
|
2016-09-13 03:59:48 -03:00
|
|
|
unpublishedEntry(collection, slug) {
|
2016-10-27 15:27:39 -02:00
|
|
|
return this.implementation.unpublishedEntry(collection, slug)
|
2016-10-28 11:42:31 -02:00
|
|
|
.then((loadedEntry) => {
|
2017-03-15 18:47:18 -07:00
|
|
|
const entry = createEntry(
|
|
|
|
"draft",
|
|
|
|
loadedEntry.slug,
|
|
|
|
loadedEntry.file.path,
|
|
|
|
{
|
|
|
|
raw: loadedEntry.data,
|
|
|
|
isModification: loadedEntry.isModification,
|
|
|
|
});
|
2016-10-28 11:42:31 -02:00
|
|
|
entry.metaData = loadedEntry.metaData;
|
|
|
|
return entry;
|
|
|
|
})
|
|
|
|
.then(this.entryWithFormat(collection, slug));
|
2016-09-13 03:59:48 -03:00
|
|
|
}
|
|
|
|
|
2017-11-11 09:48:47 -05:00
|
|
|
persistEntry(config, collection, entryDraft, MediaFiles, integrations, options = {}) {
|
2016-12-23 16:59:48 -02:00
|
|
|
const newEntry = entryDraft.getIn(["entry", "newRecord"]) || false;
|
2016-09-05 12:12:38 -03:00
|
|
|
|
|
|
|
const parsedData = {
|
2016-12-23 16:59:48 -02:00
|
|
|
title: entryDraft.getIn(["entry", "data", "title"], "No Title"),
|
|
|
|
description: entryDraft.getIn(["entry", "data", "description"], "No Description!"),
|
2016-09-05 12:12:38 -03:00
|
|
|
};
|
|
|
|
|
2016-12-23 16:59:48 -02:00
|
|
|
const entryData = entryDraft.getIn(["entry", "data"]).toJS();
|
2016-08-25 16:11:00 -03:00
|
|
|
let entryObj;
|
|
|
|
if (newEntry) {
|
2016-11-11 17:54:58 -02:00
|
|
|
if (!selectAllowNewEntries(collection)) {
|
2016-12-23 16:59:48 -02:00
|
|
|
throw (new Error("Not allowed to create new entries in this collection"));
|
2016-10-27 14:23:36 +02:00
|
|
|
}
|
2016-12-23 16:59:48 -02:00
|
|
|
const slug = slugFormatter(collection.get("slug"), entryDraft.getIn(["entry", "data"]));
|
2016-11-11 17:54:58 -02:00
|
|
|
const path = selectEntryPath(collection, slug);
|
2016-08-25 16:11:00 -03:00
|
|
|
entryObj = {
|
2016-10-28 04:51:37 +02:00
|
|
|
path,
|
2016-10-21 20:42:14 -02:00
|
|
|
slug,
|
2017-02-21 23:04:12 -08:00
|
|
|
raw: this.entryToRaw(collection, entryDraft.get("entry")),
|
2016-08-25 16:11:00 -03:00
|
|
|
};
|
|
|
|
} else {
|
2016-12-23 16:59:48 -02:00
|
|
|
const path = entryDraft.getIn(["entry", "path"]);
|
2017-02-21 23:04:12 -08:00
|
|
|
const slug = entryDraft.getIn(["entry", "slug"]);
|
2016-08-25 16:11:00 -03:00
|
|
|
entryObj = {
|
2016-10-28 04:51:37 +02:00
|
|
|
path,
|
2017-02-21 23:04:12 -08:00
|
|
|
slug,
|
|
|
|
raw: this.entryToRaw(collection, entryDraft.get("entry")),
|
2016-08-25 16:11:00 -03:00
|
|
|
};
|
|
|
|
}
|
2016-07-19 17:11:22 -03:00
|
|
|
|
2017-03-17 01:09:52 +00:00
|
|
|
const commitMessage = `${ (newEntry ? "Create " : "Update ") +
|
2016-12-23 16:59:48 -02:00
|
|
|
collection.get("label") } “${ entryObj.slug }”`;
|
2016-07-19 17:11:22 -03:00
|
|
|
|
2016-12-23 16:59:48 -02:00
|
|
|
const mode = config.get("publish_mode");
|
2016-08-30 19:06:20 -03:00
|
|
|
|
2016-12-23 16:59:48 -02:00
|
|
|
const collectionName = collection.get("name");
|
2016-08-30 19:06:20 -03:00
|
|
|
|
2017-11-11 09:48:47 -05:00
|
|
|
/**
|
|
|
|
* Determine whether an asset store integration is in use.
|
|
|
|
*/
|
|
|
|
const hasAssetStore = !!selectIntegration(integrations, null, 'assetStore');
|
|
|
|
const updatedOptions = { ...options, hasAssetStore };
|
|
|
|
|
2016-09-05 12:12:38 -03:00
|
|
|
return this.implementation.persistEntry(entryObj, MediaFiles, {
|
2017-11-11 09:48:47 -05:00
|
|
|
newEntry, parsedData, commitMessage, collectionName, mode, ...updatedOptions,
|
2016-09-05 12:12:38 -03:00
|
|
|
});
|
2016-06-06 21:53:22 -03:00
|
|
|
}
|
|
|
|
|
2017-08-14 09:00:47 -04:00
|
|
|
persistMedia(file) {
|
|
|
|
const options = {
|
|
|
|
commitMessage: `Upload ${file.path}`,
|
|
|
|
};
|
|
|
|
return this.implementation.persistMedia(file, options);
|
|
|
|
}
|
|
|
|
|
2017-07-21 23:40:33 -07:00
|
|
|
deleteEntry(config, collection, slug) {
|
|
|
|
const path = selectEntryPath(collection, slug);
|
2017-10-30 20:07:54 +00:00
|
|
|
|
|
|
|
if (!selectAllowDeletion(collection)) {
|
|
|
|
throw (new Error("Not allowed to delete entries in this collection"));
|
|
|
|
}
|
|
|
|
|
2017-07-21 23:40:33 -07:00
|
|
|
const commitMessage = `Delete ${ collection.get('label') } “${ slug }”`;
|
|
|
|
return this.implementation.deleteFile(path, commitMessage);
|
|
|
|
}
|
|
|
|
|
2017-08-14 09:00:47 -04:00
|
|
|
deleteMedia(path) {
|
|
|
|
const commitMessage = `Delete ${path}`;
|
|
|
|
return this.implementation.deleteFile(path, commitMessage);
|
|
|
|
}
|
|
|
|
|
2017-11-11 09:48:47 -05:00
|
|
|
persistUnpublishedEntry(...args) {
|
|
|
|
return this.persistEntry(...args, { unpublished: true });
|
2016-09-13 16:00:24 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
updateUnpublishedEntryStatus(collection, slug, newStatus) {
|
|
|
|
return this.implementation.updateUnpublishedEntryStatus(collection, slug, newStatus);
|
2016-09-13 14:31:18 -03:00
|
|
|
}
|
|
|
|
|
2017-01-11 20:58:15 -02:00
|
|
|
publishUnpublishedEntry(collection, slug) {
|
|
|
|
return this.implementation.publishUnpublishedEntry(collection, slug);
|
2016-09-14 18:25:45 -03:00
|
|
|
}
|
|
|
|
|
2017-03-11 13:47:36 -05:00
|
|
|
deleteUnpublishedEntry(collection, slug) {
|
|
|
|
return this.implementation.deleteUnpublishedEntry(collection, slug);
|
|
|
|
}
|
2016-09-13 14:31:18 -03:00
|
|
|
|
2016-06-06 21:53:22 -03:00
|
|
|
entryToRaw(collection, entry) {
|
2017-02-21 23:04:12 -08:00
|
|
|
const format = resolveFormat(collection, entry.toJS());
|
|
|
|
const fieldsOrder = this.fieldsOrder(collection, entry);
|
|
|
|
return format && format.toFile(entry.get("data").toJS(), fieldsOrder);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 || []).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') }`);
|
|
|
|
}
|
2017-02-21 23:59:34 -08:00
|
|
|
return file.get('fields').map(f => f.get('name')).toArray();
|
2016-06-06 21:53:22 -03:00
|
|
|
}
|
2017-05-25 17:24:48 +01:00
|
|
|
|
|
|
|
filterEntries(collection, filterRule) {
|
|
|
|
return collection.entries.filter(entry => (
|
|
|
|
entry.data[filterRule.get('field')] === filterRule.get('value')
|
|
|
|
));
|
|
|
|
}
|
2016-02-25 12:31:21 -08:00
|
|
|
}
|
|
|
|
|
2016-05-30 16:55:32 -07:00
|
|
|
export function resolveBackend(config) {
|
2016-12-23 16:59:48 -02:00
|
|
|
const name = config.getIn(["backend", "name"]);
|
2016-05-30 16:55:32 -07:00
|
|
|
if (name == null) {
|
2016-12-23 16:59:48 -02:00
|
|
|
throw new Error("No backend defined in configuration");
|
2016-05-30 16:55:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
const authStore = new LocalStorageAuthStore();
|
|
|
|
|
|
|
|
switch (name) {
|
2016-12-23 16:59:48 -02:00
|
|
|
case "test-repo":
|
2017-08-29 13:08:15 -06:00
|
|
|
return new Backend(new TestRepoBackend(config), name, authStore);
|
2016-12-23 16:59:48 -02:00
|
|
|
case "github":
|
2017-08-29 13:08:15 -06:00
|
|
|
return new Backend(new GitHubBackend(config), name, authStore);
|
2017-09-05 19:30:03 -07:00
|
|
|
case "git-gateway":
|
2017-08-29 13:08:15 -06:00
|
|
|
return new Backend(new GitGatewayBackend(config), name, authStore);
|
2016-05-30 16:55:32 -07:00
|
|
|
default:
|
2016-10-27 14:45:32 +02:00
|
|
|
throw new Error(`Backend not found: ${ name }`);
|
2016-05-30 16:55:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-21 20:42:14 -02:00
|
|
|
export const currentBackend = (function () {
|
2016-02-25 12:31:21 -08:00
|
|
|
let backend = null;
|
|
|
|
|
|
|
|
return (config) => {
|
|
|
|
if (backend) { return backend; }
|
2016-12-23 16:59:48 -02:00
|
|
|
if (config.get("backend")) {
|
2016-02-25 12:31:21 -08:00
|
|
|
return backend = resolveBackend(config);
|
|
|
|
}
|
|
|
|
};
|
2016-10-21 20:42:14 -02:00
|
|
|
}());
|