SchemaProvider: Create a common BaseSchemaProvider class

Author: mstokes-f5

lib/github_provider.js

@@ -19,10 +19,10 @@ const crypto = require('crypto');
 
 const axios = require('axios');
 
-const ResourceCache = require('./resource_cache').ResourceCache;
 const Template = require('./template').Template;
-const { BaseTemplateProvider } = require('./template_provider');
+const { BaseSchemaProvider } = require('./schema_provider');
 const { BaseDataProvider } = require('./data_provider');
+const { BaseTemplateProvider } = require('./template_provider');
 const { stripExtension } = require('./utils');
 
 class GitHubContentsApi {
@@ -76,27 +76,21 @@ class GitHubContentsApi {
 /**
  * SchemaProvider that fetches data from a GitHub repository
  */
-class GitHubSchemaProvider {
+class GitHubSchemaProvider extends BaseSchemaProvider {
     constructor(repo, schemaRootPath, options) {
+        super();
+
         options = options || {};
 
         this._rootDir = `/${schemaRootPath}`;
         this._contentsApi = new GitHubContentsApi(repo, {
             apiToken: options.apiToken
         });
-
-        this.cache = new ResourceCache(schemaName => Promise.resolve()
-            .then(() => this._contentsApi.getContentsData(`${this._rootDir}/${schemaName}.json`)));
     }
 
-    /**
-     * Get the schema associated with the supplied key
-     *
-     * @param {string} key
-     * @returns {object}
-     */
-    fetch(key) {
-        return this.cache.fetch(key);
+    _loadSchema(schemaName) {
+        return Promise.resolve()
+            .then(() => this._contentsApi.getContentsData(`${this._rootDir}/${schemaName}.json`));
     }
 
     /**

lib/schema_provider.js

@@ -20,20 +20,25 @@ const fs = require('fs');
 const ResourceCache = require('./resource_cache').ResourceCache;
 
 /**
- * SchemaProvider that fetches data from the file system
+ * Abstract base class for SchemaProvider classes
  */
-class FsSchemaProvider {
-    /**
-     * @param {string} schemaRootPath - a path to a directory containing schema files
-     */
-    constructor(schemaRootPath) {
-        this.schema_path = schemaRootPath;
-        this.cache = new ResourceCache(schemaName => new Promise((resolve, reject) => {
-            fs.readFile(`${schemaRootPath}/${schemaName}.json`, (err, data) => {
-                if (err) return reject(err);
-                return resolve(data.toString('utf8'));
-            });
-        }));
+class BaseSchemaProvider {
+    constructor() {
+        if (new.target === BaseSchemaProvider) {
+            throw new TypeError('Cannot instantiate Abstract BaseSchemaProvider');
+        }
+
+        const abstractMethods = [
+            '_loadSchema',
+            'list'
+        ];
+        abstractMethods.forEach((method) => {
+            if (this[method] === undefined) {
+                throw new TypeError(`Expected ${method} to be defined`);
+            }
+        });
+
+        this.cache = new ResourceCache(schemaName => this._loadSchema(schemaName));
     }
 
     /**
@@ -45,6 +50,29 @@ class FsSchemaProvider {
     fetch(key) {
         return this.cache.fetch(key);
     }
+}
+
+/**
+ * SchemaProvider that fetches data from the file system
+ */
+class FsSchemaProvider extends BaseSchemaProvider {
+    /**
+     * @param {string} schemaRootPath - a path to a directory containing schema files
+     */
+    constructor(schemaRootPath) {
+        super();
+
+        this.schema_path = schemaRootPath;
+    }
+
+    _loadSchema(schemaName) {
+        return new Promise((resolve, reject) => {
+            fs.readFile(`${this.schema_path}/${schemaName}.json`, (err, data) => {
+                if (err) return reject(err);
+                return resolve(data.toString('utf8'));
+            });
+        });
+    }
 
     /**
      * List all schema known to the provider
@@ -67,41 +95,34 @@ class FsSchemaProvider {
 /**
  * SchemaProvider that fetches data from an atg-storage DataStore
  */
-class DataStoreSchemaProvider {
+class DataStoreSchemaProvider extends BaseSchemaProvider {
     /**
      * @param {object} datastore - an atg-storage DataStore
      * @param {string} tsName - the key to use to access the schema in the provided DataStore
      */
     constructor(datastore, tsName) {
+        super();
+
         this.storage = datastore;
         this.tsName = tsName;
-        this.cache = new ResourceCache(
-            schemaName => this.storage.hasItem(this.tsName)
-                .then((result) => {
-                    if (result) {
-                        return Promise.resolve();
-                    }
-                    return Promise.reject(new Error(`Could not find template set "${this.tsName}" in data store`));
-                })
-                .then(() => this.storage.getItem(this.tsName))
-                .then(ts => ts.schemas[schemaName])
-                .then((schema) => {
-                    if (typeof schema === 'undefined') {
-                        return Promise.reject(new Error(`Failed to find schema named "${schemaName}"`));
-                    }
-                    return Promise.resolve(schema);
-                })
-        );
     }
 
-    /**
-     * Get the schema associated with the supplied key
-     *
-     * @param {string} key
-     * @returns {object}
-     */
-    fetch(key) {
-        return this.cache.fetch(key);
+    _loadSchema(schemaName) {
+        return this.storage.hasItem(this.tsName)
+            .then((result) => {
+                if (result) {
+                    return Promise.resolve();
+                }
+                return Promise.reject(new Error(`Could not find template set "${this.tsName}" in data store`));
+            })
+            .then(() => this.storage.getItem(this.tsName))
+            .then(ts => ts.schemas[schemaName])
+            .then((schema) => {
+                if (typeof schema === 'undefined') {
+                    return Promise.reject(new Error(`Failed to find schema named "${schemaName}"`));
+                }
+                return Promise.resolve(schema);
+            });
     }
 
     /**
@@ -123,6 +144,7 @@ class DataStoreSchemaProvider {
 }
 
 module.exports = {
+    BaseSchemaProvider,
     FsSchemaProvider,
     DataStoreSchemaProvider
 };