Add a CompositeTemplateProvider

This can be used to aggregate multiple template providers together
(e.g., templates from multiple sources).

Author: mstokes-f5

CHANGELOG.md

@@ -1,3 +1,10 @@
+# v0.20.0
+## Added
+* Add a CompositeTemplateProvider to aggregate results from multiple template providers
+
+## Changed
+* Update dependencies
+
 # v0.19.1
 ## Changed
 * Update dependencies

lib/template_provider.js

@@ -686,9 +686,136 @@ class DataStoreTemplateProvider extends BaseTemplateProvider {
     }
 }
 
+/**
+ * TemplateProvider that aggregates multiple template providers
+ */
+class CompositeTemplateProvider extends BaseTemplateProvider {
+    /**
+     * @param {BaseTemplateProvider[]} providers - an array of template providers
+     * @param {object} [supportedHashes={}] - an optional map of hash values to validate against
+     */
+    constructor(providers, supportedHashes) {
+        super(supportedHashes);
+        this.providers = providers;
+    }
+
+    _getProviderForSet(setName) {
+        return Promise.resolve()
+            .then(() => Promise.all(
+                this.providers.map(provider => Promise.all([
+                    Promise.resolve(provider),
+                    provider.hasSet(setName)
+                ]))
+            ))
+            .then(providerList => providerList
+                .filter(x => x[1])
+                .map(x => x[0]))
+            .then((providers) => {
+                if (providers.length === 0) {
+                    return Promise.reject(new Error(
+                        `Could not find template set "${setName}"`
+                    ));
+                }
+
+                return Promise.resolve(providers[0]);
+            });
+    }
+
+    _getProviderForTemplate(templatePath) {
+        const setName = templatePath.split('/')[0];
+        return this._getProviderForSet(setName);
+    }
+
+    _getSetProviderPairs(setListOrName) {
+        const initSetList = (typeof setListOrName === 'string') ? [setListOrName] : (setListOrName || []);
+
+        return Promise.resolve()
+            .then(() => (initSetList.length > 0 ? Promise.resolve(initSetList) : this.listSets()))
+            .then(setList => Promise.all(
+                setList.map(
+                    setName => this._getProviderForSet(setName)
+                        .then(provider => [setName, provider])
+                )
+            ));
+    }
+
+    _loadTemplate(templateName) {
+        return Promise.resolve()
+            .then(() => this._getProviderForTemplate(templateName))
+            .then(provider => provider.fetch(templateName));
+    }
+
+    /**
+     * Delete the template set associated with the supplied set ID
+     *
+     * @returns {Promise}
+     */
+    removeSet(setid) {
+        return this._getProviderForSet(setid)
+            .then(provider => provider.removeSet(setid));
+    }
+
+    /**
+     * Get a list of set names known to the provider
+     *
+     * @returns {Promise} Promise resolves to a string array
+     */
+    listSets() {
+        return Promise.all(
+            this.providers.map(provider => provider.listSets())
+        )
+            .then(setLists => [...new Set(setLists.flat())]);
+    }
+
+    /**
+     * List all templates known to the provider (optionally filtered by the supplied list of set names)
+     *
+     * @param {string[]} [setList=[]]
+     * @returns {Promise} Promise resolves to a string array
+     */
+    list(setList) {
+        return this._getSetProviderPairs(setList)
+            .then(pairs => Promise.all(pairs.map(([setName, provider]) => provider.list(setName))))
+            .then(setLists => setLists.flat());
+    }
+
+    /**
+     * Get all schema known to the provider (optionally filtered by the supplied set name)
+     *
+     * @param {string} [filteredSetName] - only return data for this template set (instead of all template sets)
+     * @returns {Promise} Promise resolves to an object containing schema
+     */
+    getSchemas(filteredSetName) {
+        return this._getSetProviderPairs(filteredSetName)
+            .then(pairs => Promise.all(pairs.map(([setName, provider]) => provider.getSchemas(setName))))
+            .then(data => Object.assign({}, ...data));
+    }
+
+    /**
+     * Get all data files known to the provider (optionally filtered by the supplied set name)
+     *
+     * @param {string} [filteredSetName] - only return data for this template set (instead of all template sets)
+     * @returns {Promise} Promise resolves to an object containing data files
+     */
+    getDataFiles(filteredSetName) {
+        return this._getSetProviderPairs(filteredSetName)
+            .then(pairs => Promise.all(pairs.map(([setName, provider]) => provider.getDataFiles(setName))))
+            .then(data => Object.assign({}, ...data));
+    }
+
+    /**
+     * Clear any cache associated with this provider
+     */
+    invalidateCache() {
+        super.invalidateCache();
+        this.providers.forEach(provider => provider.invalidateCache());
+    }
+}
+
 module.exports = {
     BaseTemplateProvider,
     FsTemplateProvider,
     FsSingleTemplateProvider,
-    DataStoreTemplateProvider
+    DataStoreTemplateProvider,
+    CompositeTemplateProvider
 };

test/template_provider.js

@@ -30,7 +30,8 @@ const StorageMemory = require('@f5devcentral/atg-storage').StorageMemory;
 const {
     FsTemplateProvider,
     FsSingleTemplateProvider,
-    DataStoreTemplateProvider
+    DataStoreTemplateProvider,
+    CompositeTemplateProvider
 } = require('../lib/template_provider');
 
 const { GitHubTemplateProvider } = require('../lib/github_provider');
@@ -226,6 +227,7 @@ describe('template provider tests', function () {
     describe('DataStoreTemplateProvider', function () {
         const testStorage = new StorageMemory();
         before(function () {
+            testStorage.data = {};
             return DataStoreTemplateProvider.fromFs(testStorage, templatesPath);
         });
         const createProvider = filtered => new DataStoreTemplateProvider(testStorage, filtered);
@@ -261,4 +263,18 @@ describe('template provider tests', function () {
             )
         );
     });
+    describe('CompositeTemplateProvider', function () {
+        const testStorage = new StorageMemory();
+        before(function () {
+            testStorage.data = {};
+            return DataStoreTemplateProvider.fromFs(testStorage, templatesPath);
+        });
+
+        runSharedTests(
+            filtered => new CompositeTemplateProvider([
+                new FsTemplateProvider(templatesPath, filtered),
+                new DataStoreTemplateProvider(testStorage, filtered)
+            ])
+        );
+    });
 });