@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/api/controllers/table/internal.js

@@ -0,0 +1,194 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkImport = exports.destroy = exports.save = void 0;
+const linkedRows_1 = require("../../../db/linkedRows");
+const utils_1 = require("../../../db/utils");
+const constants_1 = require("../../../constants");
+const utils_2 = require("./utils");
+const backend_core_1 = require("@budibase/backend-core");
+const environment_1 = __importDefault(require("../../../environment"));
+const rowProcessor_1 = require("../../../utilities/rowProcessor");
+const bulkFormula_1 = require("./bulkFormula");
+const pro_1 = require("@budibase/pro");
+const lodash_1 = require("lodash");
+const fp_1 = require("lodash/fp");
+const sdk_1 = __importDefault(require("../../../sdk"));
+function checkAutoColumns(table, oldTable) {
+    if (!table.schema) {
+        return table;
+    }
+    for (let [key, schema] of Object.entries(table.schema)) {
+        if (!schema.autocolumn || schema.subtype) {
+            continue;
+        }
+        const oldSchema = oldTable && oldTable.schema[key];
+        if (oldSchema && oldSchema.subtype) {
+            table.schema[key].subtype = oldSchema.subtype;
+        }
+        else {
+            table.schema[key] = (0, rowProcessor_1.fixAutoColumnSubType)(schema);
+        }
+    }
+    return table;
+}
+function save(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const _a = ctx.request.body, { rows } = _a, rest = __rest(_a, ["rows"]);
+        let tableToSave = Object.assign({ type: "table", _id: (0, utils_1.generateTableID)(), views: {} }, rest);
+        // if the table obj had an _id then it will have been retrieved
+        let oldTable;
+        if (ctx.request.body && ctx.request.body._id) {
+            oldTable = yield db.get(ctx.request.body._id);
+        }
+        // check all types are correct
+        if ((0, utils_2.hasTypeChanged)(tableToSave, oldTable)) {
+            ctx.throw(400, "A column type has changed.");
+        }
+        // check that subtypes have been maintained
+        tableToSave = checkAutoColumns(tableToSave, oldTable);
+        // saving a table is a complex operation, involving many different steps, this
+        // has been broken out into a utility to make it more obvious/easier to manipulate
+        const tableSaveFunctions = new utils_2.TableSaveFunctions({
+            user: ctx.user,
+            oldTable,
+            importRows: rows,
+        });
+        tableToSave = yield tableSaveFunctions.before(tableToSave);
+        // make sure that types don't change of a column, have to remove
+        // the column if you want to change the type
+        if (oldTable && oldTable.schema) {
+            for (let propKey of Object.keys(tableToSave.schema)) {
+                let oldColumn = oldTable.schema[propKey];
+                if (oldColumn && oldColumn.type === "internal") {
+                    oldColumn.type = "auto";
+                }
+            }
+        }
+        // Don't rename if the name is the same
+        let { _rename } = tableToSave;
+        /* istanbul ignore next */
+        if (_rename && _rename.old === _rename.updated) {
+            _rename = null;
+            delete tableToSave._rename;
+        }
+        // rename row fields when table column is renamed
+        /* istanbul ignore next */
+        if (_rename && tableToSave.schema[_rename.updated].type === constants_1.FieldTypes.LINK) {
+            ctx.throw(400, "Cannot rename a linked column.");
+        }
+        tableToSave = yield tableSaveFunctions.mid(tableToSave);
+        // update schema of non-statistics views when new columns are added
+        for (let view in tableToSave.views) {
+            const tableView = tableToSave.views[view];
+            if (!tableView)
+                continue;
+            if (tableView.schema.group || tableView.schema.field)
+                continue;
+            tableView.schema = tableToSave.schema;
+        }
+        // update linked rows
+        try {
+            const linkResp = yield (0, linkedRows_1.updateLinks)({
+                eventType: oldTable ? linkedRows_1.EventType.TABLE_UPDATED : linkedRows_1.EventType.TABLE_SAVE,
+                table: tableToSave,
+                oldTable: oldTable,
+            });
+            if (linkResp != null && linkResp._rev) {
+                tableToSave._rev = linkResp._rev;
+            }
+        }
+        catch (err) {
+            ctx.throw(400, err);
+        }
+        // don't perform any updates until relationships have been
+        // checked by the updateLinks function
+        const updatedRows = tableSaveFunctions.getUpdatedRows();
+        if (updatedRows && updatedRows.length !== 0) {
+            yield db.bulkDocs(updatedRows);
+        }
+        let result = yield db.put(tableToSave);
+        tableToSave._rev = result.rev;
+        const savedTable = (0, fp_1.cloneDeep)(tableToSave);
+        tableToSave = yield tableSaveFunctions.after(tableToSave);
+        // the table may be updated as part of the table save after functionality - need to write it
+        if (!(0, lodash_1.isEqual)(savedTable, tableToSave)) {
+            result = yield db.put(tableToSave);
+            tableToSave._rev = result.rev;
+        }
+        // has to run after, make sure it has _id
+        yield (0, bulkFormula_1.runStaticFormulaChecks)(tableToSave, { oldTable, deletion: false });
+        return tableToSave;
+    });
+}
+exports.save = save;
+function destroy(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const tableToDelete = yield db.get(ctx.params.tableId);
+        // Delete all rows for that table
+        const rowsData = yield db.allDocs((0, utils_1.getRowParams)(ctx.params.tableId, null, {
+            include_docs: true,
+        }));
+        yield db.bulkDocs(rowsData.rows.map((row) => (Object.assign(Object.assign({}, row.doc), { _deleted: true }))));
+        yield pro_1.quotas.removeRows(rowsData.rows.length, {
+            tableId: ctx.params.tableId,
+        });
+        // update linked rows
+        yield (0, linkedRows_1.updateLinks)({
+            eventType: linkedRows_1.EventType.TABLE_DELETE,
+            table: tableToDelete,
+        });
+        // don't remove the table itself until very end
+        yield db.remove(tableToDelete._id, tableToDelete._rev);
+        // remove table search index
+        if (!environment_1.default.isTest() || environment_1.default.COUCH_DB_URL) {
+            const currentIndexes = yield db.getIndexes();
+            const existingIndex = currentIndexes.indexes.find((existing) => existing.name === `search:${ctx.params.tableId}`);
+            if (existingIndex) {
+                yield db.deleteIndex(existingIndex);
+            }
+        }
+        // has to run after, make sure it has _id
+        yield (0, bulkFormula_1.runStaticFormulaChecks)(tableToDelete, {
+            deletion: true,
+        });
+        yield (0, rowProcessor_1.cleanupAttachments)(tableToDelete, {
+            rows: rowsData.rows.map((row) => row.doc),
+        });
+        return tableToDelete;
+    });
+}
+exports.destroy = destroy;
+function bulkImport(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield sdk_1.default.tables.getTable(ctx.params.tableId);
+        const { rows } = ctx.request.body;
+        yield (0, utils_2.handleDataImport)(ctx.user, table, rows);
+        return table;
+    });
+}
+exports.bulkImport = bulkImport;

package/dist/api/controllers/table/utils.js

@@ -0,0 +1,374 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableSaveFunctions = exports.setStaticSchemas = exports.hasTypeChanged = exports.areSwitchableTypes = exports.foreignKeyStructure = exports.generateJunctionTableName = exports.generateForeignKey = exports.checkForViewUpdates = exports.checkStaticTables = exports.handleSearchIndexes = exports.handleDataImport = exports.importToRows = exports.makeSureTableUpToDate = exports.checkForColumnUpdates = exports.clearColumns = void 0;
+const schema_1 = require("../../../utilities/schema");
+const utils_1 = require("../../../db/utils");
+const lodash_1 = require("lodash");
+const constants_1 = require("../../../constants");
+const rowProcessor_1 = require("../../../utilities/rowProcessor");
+const constants_2 = require("../../../constants");
+const utils_2 = require("../view/utils");
+const viewBuilder_1 = __importDefault(require("../view/viewBuilder"));
+const fp_1 = require("lodash/fp");
+const pro_1 = require("@budibase/pro");
+const backend_core_1 = require("@budibase/backend-core");
+const types_1 = require("@budibase/types");
+function clearColumns(table, columnNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        const rows = yield db.allDocs((0, utils_1.getRowParams)(table._id, null, {
+            include_docs: true,
+        }));
+        return (yield db.bulkDocs(rows.rows.map(({ doc }) => {
+            columnNames.forEach((colName) => delete doc[colName]);
+            return doc;
+        })));
+    });
+}
+exports.clearColumns = clearColumns;
+function checkForColumnUpdates(oldTable, updatedTable) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        let updatedRows = [];
+        const rename = updatedTable._rename;
+        let deletedColumns = [];
+        if (oldTable && oldTable.schema && updatedTable.schema) {
+            deletedColumns = Object.keys(oldTable.schema).filter(colName => updatedTable.schema[colName] == null);
+        }
+        // check for renaming of columns or deleted columns
+        if (rename || deletedColumns.length !== 0) {
+            // Update all rows
+            const rows = yield db.allDocs((0, utils_1.getRowParams)(updatedTable._id, null, {
+                include_docs: true,
+            }));
+            const rawRows = rows.rows.map(({ doc }) => doc);
+            updatedRows = rawRows.map((row) => {
+                row = (0, fp_1.cloneDeep)(row);
+                if (rename) {
+                    row[rename.updated] = row[rename.old];
+                    delete row[rename.old];
+                }
+                else if (deletedColumns.length !== 0) {
+                    deletedColumns.forEach((colName) => delete row[colName]);
+                }
+                return row;
+            });
+            // cleanup any attachments from object storage for deleted attachment columns
+            yield (0, rowProcessor_1.cleanupAttachments)(updatedTable, { oldTable, rows: rawRows });
+            // Update views
+            yield checkForViewUpdates(updatedTable, rename, deletedColumns);
+            delete updatedTable._rename;
+        }
+        return { rows: updatedRows, table: updatedTable };
+    });
+}
+exports.checkForColumnUpdates = checkForColumnUpdates;
+// makes sure the passed in table isn't going to reset the auto ID
+function makeSureTableUpToDate(table, tableToSave) {
+    if (!table) {
+        return tableToSave;
+    }
+    // sure sure rev is up to date
+    tableToSave._rev = table._rev;
+    // make sure auto IDs are always updated - these are internal
+    // so the client may not know they have changed
+    let field;
+    let column;
+    for ([field, column] of Object.entries(table.schema)) {
+        if (column.autocolumn &&
+            column.subtype === constants_1.AutoFieldSubTypes.AUTO_ID &&
+            tableToSave.schema[field]) {
+            tableToSave.schema[field].lastID = column.lastID;
+        }
+    }
+    return tableToSave;
+}
+exports.makeSureTableUpToDate = makeSureTableUpToDate;
+function importToRows(data, table, user = null) {
+    let finalData = [];
+    for (let i = 0; i < data.length; i++) {
+        let row = data[i];
+        row._id = (0, utils_1.generateRowID)(table._id);
+        row.tableId = table._id;
+        const processed = (0, rowProcessor_1.inputProcessing)(user, table, row, {
+            noAutoRelationships: true,
+        });
+        row = processed.row;
+        table = processed.table;
+        for (const [fieldName, schema] of Object.entries(table.schema)) {
+            // check whether the options need to be updated for inclusion as part of the data import
+            if ((schema.type === constants_1.FieldTypes.OPTIONS ||
+                schema.type === constants_1.FieldTypes.ARRAY) &&
+                row[fieldName] &&
+                (!schema.constraints.inclusion ||
+                    schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
+                schema.constraints.inclusion = [
+                    ...schema.constraints.inclusion,
+                    row[fieldName],
+                ];
+                schema.constraints.inclusion.sort();
+            }
+        }
+        finalData.push(row);
+    }
+    return finalData;
+}
+exports.importToRows = importToRows;
+function handleDataImport(user, table, rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const schema = table.schema;
+        if (!rows || !(0, schema_1.isRows)(rows) || !(0, schema_1.isSchema)(schema)) {
+            return table;
+        }
+        const db = backend_core_1.context.getAppDB();
+        const data = (0, schema_1.parse)(rows, schema);
+        let finalData = importToRows(data, table, user);
+        yield pro_1.quotas.addRows(finalData.length, () => db.bulkDocs(finalData), {
+            tableId: table._id,
+        });
+        yield backend_core_1.events.rows.imported(table, finalData.length);
+        return table;
+    });
+}
+exports.handleDataImport = handleDataImport;
+function handleSearchIndexes(table) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = backend_core_1.context.getAppDB();
+        // create relevant search indexes
+        if (table.indexes && table.indexes.length > 0) {
+            const currentIndexes = yield db.getIndexes();
+            const indexName = `search:${table._id}`;
+            const existingIndex = currentIndexes.indexes.find((existing) => existing.name === indexName);
+            if (existingIndex) {
+                const currentFields = existingIndex.def.fields.map((field) => Object.keys(field)[0]);
+                // if index fields have changed, delete the original index
+                if (!(0, lodash_1.isEqual)(currentFields, table.indexes)) {
+                    yield db.deleteIndex(existingIndex);
+                    // create/recreate the index with fields
+                    yield db.createIndex({
+                        index: {
+                            fields: table.indexes,
+                            name: indexName,
+                            ddoc: "search_ddoc",
+                            type: "json",
+                        },
+                    });
+                }
+            }
+            else {
+                // create/recreate the index with fields
+                yield db.createIndex({
+                    index: {
+                        fields: table.indexes,
+                        name: indexName,
+                        ddoc: "search_ddoc",
+                        type: "json",
+                    },
+                });
+            }
+        }
+        return table;
+    });
+}
+exports.handleSearchIndexes = handleSearchIndexes;
+function checkStaticTables(table) {
+    // check user schema has all required elements
+    if (table._id === utils_1.InternalTables.USER_METADATA) {
+        for (let [key, schema] of Object.entries(constants_2.USERS_TABLE_SCHEMA.schema)) {
+            // check if the schema exists on the table to be created/updated
+            if (table.schema[key] == null) {
+                table.schema[key] = schema;
+            }
+        }
+    }
+    return table;
+}
+exports.checkStaticTables = checkStaticTables;
+class TableSaveFunctions {
+    constructor({ user, oldTable, importRows }) {
+        this.db = backend_core_1.context.getAppDB();
+        this.user = user;
+        this.oldTable = oldTable;
+        this.importRows = importRows;
+        // any rows that need updated
+        this.rows = [];
+    }
+    // before anything is done
+    before(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.oldTable) {
+                table = makeSureTableUpToDate(this.oldTable, table);
+            }
+            table = checkStaticTables(table);
+            return table;
+        });
+    }
+    // when confirmed valid
+    mid(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let response = yield checkForColumnUpdates(this.oldTable, table);
+            this.rows = this.rows.concat(response.rows);
+            return table;
+        });
+    }
+    // after saving
+    after(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            table = yield handleSearchIndexes(table);
+            table = yield handleDataImport(this.user, table, this.importRows);
+            return table;
+        });
+    }
+    getUpdatedRows() {
+        return this.rows;
+    }
+}
+function checkForViewUpdates(table, rename, deletedColumns) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const views = yield (0, utils_2.getViews)();
+        const tableViews = views.filter(view => view.meta.tableId === table._id);
+        // Check each table view to see if impacted by this table action
+        for (let view of tableViews) {
+            let needsUpdated = false;
+            // First check for renames, otherwise check for deletions
+            if (rename) {
+                // Update calculation field if required
+                if (view.meta.field === rename.old) {
+                    view.meta.field = rename.updated;
+                    needsUpdated = true;
+                }
+                // Update group by field if required
+                if (view.meta.groupBy === rename.old) {
+                    view.meta.groupBy = rename.updated;
+                    needsUpdated = true;
+                }
+                // Update filters if required
+                if (view.meta.filters) {
+                    view.meta.filters.forEach((filter) => {
+                        if (filter.key === rename.old) {
+                            filter.key = rename.updated;
+                            needsUpdated = true;
+                        }
+                    });
+                }
+            }
+            else if (deletedColumns) {
+                deletedColumns.forEach((column) => {
+                    // Remove calculation statement if required
+                    if (view.meta.field === column) {
+                        delete view.meta.field;
+                        delete view.meta.calculation;
+                        delete view.meta.groupBy;
+                        needsUpdated = true;
+                    }
+                    // Remove group by field if required
+                    if (view.meta.groupBy === column) {
+                        delete view.meta.groupBy;
+                        needsUpdated = true;
+                    }
+                    // Remove filters referencing deleted field if required
+                    if (view.meta.filters && view.meta.filters.length) {
+                        const initialLength = view.meta.filters.length;
+                        view.meta.filters = view.meta.filters.filter((filter) => {
+                            return filter.key !== column;
+                        });
+                        if (initialLength !== view.meta.filters.length) {
+                            needsUpdated = true;
+                        }
+                    }
+                });
+            }
+            // Update view if required
+            if (needsUpdated) {
+                const groupByField = Object.values(table.schema).find((field) => field.name == view.groupBy);
+                const newViewTemplate = (0, viewBuilder_1.default)(view.meta, (groupByField === null || groupByField === void 0 ? void 0 : groupByField.type) === constants_1.FieldTypes.ARRAY);
+                yield (0, utils_2.saveView)(null, view.name, newViewTemplate);
+                if (!newViewTemplate.meta.schema) {
+                    newViewTemplate.meta.schema = table.schema;
+                }
+                table.views[view.name] = newViewTemplate.meta;
+            }
+        }
+    });
+}
+exports.checkForViewUpdates = checkForViewUpdates;
+function generateForeignKey(column, relatedTable) {
+    return `fk_${relatedTable.name}_${column.fieldName}`;
+}
+exports.generateForeignKey = generateForeignKey;
+function generateJunctionTableName(column, table, relatedTable) {
+    return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`;
+}
+exports.generateJunctionTableName = generateJunctionTableName;
+function foreignKeyStructure(keyName, meta) {
+    const structure = {
+        type: constants_1.FieldTypes.NUMBER,
+        constraints: {},
+        name: keyName,
+    };
+    if (meta) {
+        structure.meta = meta;
+    }
+    return structure;
+}
+exports.foreignKeyStructure = foreignKeyStructure;
+function areSwitchableTypes(type1, type2) {
+    if (constants_2.SwitchableTypes.indexOf(type1) === -1 &&
+        constants_2.SwitchableTypes.indexOf(type2) === -1) {
+        return false;
+    }
+    for (let option of constants_2.CanSwitchTypes) {
+        const index1 = option.indexOf(type1), index2 = option.indexOf(type2);
+        if (index1 !== -1 && index2 !== -1 && index1 !== index2) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.areSwitchableTypes = areSwitchableTypes;
+function hasTypeChanged(table, oldTable) {
+    if (!oldTable) {
+        return false;
+    }
+    let key;
+    let field;
+    for ([key, field] of Object.entries(oldTable.schema)) {
+        const oldType = field.type;
+        if (!table.schema[key]) {
+            continue;
+        }
+        const newType = table.schema[key].type;
+        if (oldType !== newType && !areSwitchableTypes(oldType, newType)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasTypeChanged = hasTypeChanged;
+// used for external tables, some of them will have static schemas that need
+// to be hard set
+function setStaticSchemas(datasource, table) {
+    var _a;
+    // GSheets is a specific case - only ever has a static primary key
+    if (table && datasource.source === types_1.SourceName.GOOGLE_SHEETS) {
+        table.primary = [constants_1.GOOGLE_SHEETS_PRIMARY_KEY];
+        // if there is an id column, remove it, should never exist in GSheets
+        (_a = table.schema) === null || _a === void 0 ? true : delete _a.id;
+    }
+    return table;
+}
+exports.setStaticSchemas = setStaticSchemas;
+const _TableSaveFunctions = TableSaveFunctions;
+exports.TableSaveFunctions = _TableSaveFunctions;

package/dist/api/controllers/templates.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadTemplate = exports.fetch = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const fileSystem_1 = require("../../utilities/fileSystem");
+const environment_1 = __importDefault(require("../../environment"));
+// development flag, can be used to test against templates exported locally
+const DEFAULT_TEMPLATES_BUCKET = "prod-budi-templates.s3-eu-west-1.amazonaws.com";
+function fetch(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let type = environment_1.default.TEMPLATE_REPOSITORY;
+        let response, error = false;
+        try {
+            response = yield (0, node_fetch_1.default)(`https://${DEFAULT_TEMPLATES_BUCKET}/manifest.json`);
+            if (response.status !== 200) {
+                error = true;
+            }
+        }
+        catch (err) {
+            error = true;
+        }
+        // if there is an error, simply return no templates
+        if (!error && response) {
+            const json = yield response.json();
+            ctx.body = Object.values(json.templates[type]);
+        }
+        else {
+            ctx.body = [];
+        }
+    });
+}
+exports.fetch = fetch;
+// can't currently test this, have to ignore from coverage
+/* istanbul ignore next */
+function downloadTemplate(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { type, name } = ctx.params;
+        yield (0, fileSystem_1.downloadTemplate)(type, name);
+        ctx.body = {
+            message: `template ${type}:${name} downloaded successfully.`,
+        };
+    });
+}
+exports.downloadTemplate = downloadTemplate;