@balena/pinejs 15.0.0-true-boolean-7896b116c446d891d7a0d5e4085c02a13bc9c725 → 15.0.1-build-migrations-clarify-marking-sbvr-optional-d6d0ded8eccc6eadb2492f4697918cf0afd00215-1

package/out/sbvr-api/sbvr-utils.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setup = exports.executeStandardModels = exports.handleODataRequest = exports.getAffectedIds = exports.getAbstractSqlModel = exports.runURI = exports.api = exports.PinejsClient = exports.runRule = exports.getID = exports.deleteModel = exports.executeModels = exports.executeModel = exports.generateModels = exports.generateSqlModel = exports.generateAbstractSqlModel = exports.generateLfModel = exports.validateModel = exports.resolveNavigationResource = exports.resolveSynonym = exports.resolveOdataBind = exports.sbvrTypes = exports.db = exports.addSideEffectHook = exports.addPureHook = void 0;
-const Bluebird = require("bluebird");
+exports.setup = exports.executeStandardModels = exports.handleHttpErrors = exports.onHandleHttpError = exports.handleODataRequest = exports.getAffectedIds = exports.getAbstractSqlModel = exports.runURI = exports.api = exports.PinejsClient = exports.runRule = exports.getID = exports.deleteModel = exports.executeModels = exports.executeModel = exports.generateModels = exports.generateSqlModel = exports.generateAbstractSqlModel = exports.generateLfModel = exports.validateModel = exports.isModelNew = exports.resolveNavigationResource = exports.resolveSynonym = exports.resolveOdataBind = exports.sbvrTypes = exports.db = exports.addSideEffectHook = exports.addPureHook = void 0;
 const _ = require("lodash");
 const cached_compile_1 = require("./cached-compile");
 const AbstractSQLCompiler = require("@balena/abstract-sql-compiler");
 const package_json_1 = require("@balena/abstract-sql-compiler/package.json");
 const LF2AbstractSQL = require("@balena/lf-to-abstract-sql");
 const odata_to_abstract_sql_1 = require("@balena/odata-to-abstract-sql");
-const sbvrTypes = require("@balena/sbvr-types");
-exports.sbvrTypes = sbvrTypes;
+const sbvr_types_1 = require("@balena/sbvr-types");
+exports.sbvrTypes = sbvr_types_1.default;
 const deepFreeze = require("deep-freeze");
 const pinejs_client_core_1 = require("pinejs-client-core");
 const extended_sbvr_parser_1 = require("../extended-sbvr-parser/extended-sbvr-parser");
-const migrator = require("../migrator/migrator");
+const asyncMigrator = require("../migrator/async");
+const syncMigrator = require("../migrator/sync");
 const odata_metadata_generator_1 = require("../odata-metadata/odata-metadata-generator");
 const devModel = require('./dev.sbvr');
 const permissions = require("./permissions");
@@ -33,11 +33,12 @@ var abstract_sql_2 = require("./abstract-sql");
 Object.defineProperty(exports, "resolveOdataBind", { enumerable: true, get: function () { return abstract_sql_2.resolveOdataBind; } });
 const odataResponse = require("./odata-response");
 const module_1 = require("../server-glue/module");
-const LF2AbstractSQLTranslator = LF2AbstractSQL.createTranslator(sbvrTypes);
+const translations_1 = require("./translations");
+const LF2AbstractSQLTranslator = LF2AbstractSQL.createTranslator(sbvr_types_1.default);
 const LF2AbstractSQLTranslatorVersion = `${package_json_2.version}+${package_json_3.version}`;
 const models = {};
 const memoizedResolvedSynonym = memoizeWeak((abstractSqlModel, resourceName) => {
-    const sqlName = odata_to_abstract_sql_1.odataNameToSqlName(resourceName);
+    const sqlName = (0, odata_to_abstract_sql_1.odataNameToSqlName)(resourceName);
     return _(sqlName)
         .split('-')
         .map((namePart) => {
@@ -50,16 +51,15 @@ const memoizedResolvedSynonym = memoizeWeak((abstractSqlModel, resourceName) =>
         .join('-');
 }, { primitive: true });
 const resolveSynonym = (request) => {
-    const abstractSqlModel = exports.getAbstractSqlModel(request);
+    const abstractSqlModel = (0, exports.getAbstractSqlModel)(request);
     return memoizedResolvedSynonym(abstractSqlModel, request.resourceName);
 };
 exports.resolveSynonym = resolveSynonym;
 const memoizedResolveNavigationResource = memoizeWeak((abstractSqlModel, resourceName, navigationName) => {
-    const navigation = _(odata_to_abstract_sql_1.odataNameToSqlName(navigationName))
+    const navigation = (0, odata_to_abstract_sql_1.odataNameToSqlName)(navigationName)
         .split('-')
-        .flatMap((namePart) => memoizedResolvedSynonym(abstractSqlModel, namePart).split('-'))
-        .concat('$')
-        .value();
+        .flatMap((namePart) => memoizedResolvedSynonym(abstractSqlModel, namePart).split('-'));
+    navigation.push('$');
     const resolvedResourceName = memoizedResolvedSynonym(abstractSqlModel, resourceName);
     const mapping = _.get(abstractSqlModel.relationships[resolvedResourceName], navigation);
     if (mapping == null) {
@@ -68,10 +68,10 @@ const memoizedResolveNavigationResource = memoizeWeak((abstractSqlModel, resourc
     if (mapping.length < 2) {
         throw new Error(`'${resourceName}' to '${navigationName}' is a field not a navigation`);
     }
-    return odata_to_abstract_sql_1.sqlNameToODataName(abstractSqlModel.tables[mapping[1][0]].name);
+    return (0, odata_to_abstract_sql_1.sqlNameToODataName)(abstractSqlModel.tables[mapping[1][0]].name);
 }, { primitive: true });
 const resolveNavigationResource = (request, navigationName) => {
-    const abstractSqlModel = exports.getAbstractSqlModel(request);
+    const abstractSqlModel = (0, exports.getAbstractSqlModel)(request);
     return memoizedResolveNavigationResource(abstractSqlModel, request.resourceName, navigationName);
 };
 exports.resolveNavigationResource = resolveNavigationResource;
@@ -81,11 +81,12 @@ const prettifyConstraintError = (err, request) => {
         if (err instanceof exports.db.UniqueConstraintError) {
             switch (exports.db.engine) {
                 case 'mysql':
-                    matches = /ER_DUP_ENTRY: Duplicate entry '.*?[^\\]' for key '(.*?[^\\])'/.exec(err.message);
+                    matches =
+                        /ER_DUP_ENTRY: Duplicate entry '.*?[^\\]' for key '(.*?[^\\])'/.exec(err.message);
                     break;
                 case 'postgres':
-                    const resourceName = exports.resolveSynonym(request);
-                    const abstractSqlModel = exports.getAbstractSqlModel(request);
+                    const resourceName = (0, exports.resolveSynonym)(request);
+                    const abstractSqlModel = getFinalAbstractSqlModel(request);
                     matches = new RegExp('"' + abstractSqlModel.tables[resourceName].name + '_(.*?)_key"').exec(err.message);
                     break;
             }
@@ -103,11 +104,12 @@ const prettifyConstraintError = (err, request) => {
         if (err instanceof exports.db.ForeignKeyConstraintError) {
             switch (exports.db.engine) {
                 case 'mysql':
-                    matches = /ER_ROW_IS_REFERENCED_: Cannot delete or update a parent row: a foreign key constraint fails \(".*?"\.(".*?").*/.exec(err.message);
+                    matches =
+                        /ER_ROW_IS_REFERENCED_: Cannot delete or update a parent row: a foreign key constraint fails \(".*?"\.(".*?").*/.exec(err.message);
                     break;
                 case 'postgres':
-                    const resourceName = exports.resolveSynonym(request);
-                    const abstractSqlModel = exports.getAbstractSqlModel(request);
+                    const resourceName = (0, exports.resolveSynonym)(request);
+                    const abstractSqlModel = getFinalAbstractSqlModel(request);
                     const tableName = abstractSqlModel.tables[resourceName].name;
                     matches = new RegExp('"' +
                         tableName +
@@ -124,11 +126,11 @@ const prettifyConstraintError = (err, request) => {
             if (matches == null) {
                 throw new exports.db.ForeignKeyConstraintError('Foreign key constraint violated');
             }
-            throw new exports.db.ForeignKeyConstraintError('Data is referenced by ' + odata_to_abstract_sql_1.sqlNameToODataName(matches[1]) + '.');
+            throw new exports.db.ForeignKeyConstraintError('Data is referenced by ' + (0, odata_to_abstract_sql_1.sqlNameToODataName)(matches[1]) + '.');
         }
         if (err instanceof exports.db.CheckConstraintError) {
-            const resourceName = exports.resolveSynonym(request);
-            const abstractSqlModel = exports.getAbstractSqlModel(request);
+            const resourceName = (0, exports.resolveSynonym)(request);
+            const abstractSqlModel = getFinalAbstractSqlModel(request);
             const table = abstractSqlModel.tables[resourceName];
             if (table.checks) {
                 switch (exports.db.engine) {
@@ -142,7 +144,7 @@ const prettifyConstraintError = (err, request) => {
             if (matches != null) {
                 const checkName = matches[1];
                 const check = table.checks.find((c) => c.name === checkName);
-                if ((check === null || check === void 0 ? void 0 : check.description) != null) {
+                if (check?.description != null) {
                     throw new errors_1.BadRequestError(check.description);
                 }
             }
@@ -152,14 +154,54 @@ const prettifyConstraintError = (err, request) => {
         throw err;
     }
 };
+let cachedIsModelNew;
+const isModelNew = async (tx, modelName) => {
+    const result = await tx.tableList("name = 'model'");
+    if (result.rows.length === 0) {
+        return true;
+    }
+    if (cachedIsModelNew == null) {
+        const { rows } = await tx.executeSql(`SELECT "is of-vocabulary" FROM "model";`);
+        cachedIsModelNew = new Set(rows.map((row) => row['is of-vocabulary']));
+    }
+    return !cachedIsModelNew.has(modelName);
+};
+exports.isModelNew = isModelNew;
+const bindsForAffectedIds = (bindings, request) => {
+    if (request?.affectedIds == null) {
+        return {};
+    }
+    const tableName = (0, exports.getAbstractSqlModel)(request).tables[(0, exports.resolveSynonym)(request)].name;
+    const isDelete = request.method === 'DELETE';
+    const odataBinds = {};
+    for (const bind of bindings) {
+        if (bind.length !== 2 ||
+            bind[0] !== 'Bind' ||
+            typeof bind[1] !== 'string') {
+            continue;
+        }
+        const bindName = bind[1];
+        if (!isDelete && bindName === tableName) {
+            odataBinds[bindName] = ['Text', `{${request.affectedIds}}`];
+        }
+        else {
+            odataBinds[bindName] = ['Text', '{}'];
+        }
+    }
+    return odataBinds;
+};
 const validateModel = async (tx, modelName, request) => {
-    await Promise.all(models[modelName].sql.rules.map(async (rule) => {
-        if (!abstract_sql_1.isRuleAffected(rule, request)) {
+    const { sql } = models[modelName];
+    if (!sql) {
+        throw new Error(`Tried to validate a virtual model: '${modelName}'`);
+    }
+    await Promise.all(sql.rules.map(async (rule) => {
+        if (!(0, abstract_sql_1.isRuleAffected)(rule, request)) {
             return;
         }
-        const values = await abstract_sql_1.getAndCheckBindValues({
+        const values = await (0, abstract_sql_1.getAndCheckBindValues)({
             vocabulary: modelName,
-            odataBinds: [],
+            odataBinds: bindsForAffectedIds(rule.bindings, request),
             values: {},
             engine: exports.db.engine,
         }, rule.bindings);
@@ -171,26 +213,26 @@ const validateModel = async (tx, modelName, request) => {
     }));
 };
 exports.validateModel = validateModel;
-const generateLfModel = (seModel) => cached_compile_1.cachedCompile('lfModel', extended_sbvr_parser_1.ExtendedSBVRParser.version, seModel, () => extended_sbvr_parser_1.ExtendedSBVRParser.matchAll(seModel, 'Process'));
+const generateLfModel = (seModel) => (0, cached_compile_1.cachedCompile)('lfModel', extended_sbvr_parser_1.ExtendedSBVRParser.version, seModel, () => extended_sbvr_parser_1.ExtendedSBVRParser.matchAll(seModel, 'Process'));
 exports.generateLfModel = generateLfModel;
-const generateAbstractSqlModel = (lfModel) => cached_compile_1.cachedCompile('abstractSqlModel', LF2AbstractSQLTranslatorVersion, lfModel, () => LF2AbstractSQLTranslator(lfModel, 'Process'));
+const generateAbstractSqlModel = (lfModel) => (0, cached_compile_1.cachedCompile)('abstractSqlModel', LF2AbstractSQLTranslatorVersion, lfModel, () => LF2AbstractSQLTranslator(lfModel, 'Process'));
 exports.generateAbstractSqlModel = generateAbstractSqlModel;
-const generateSqlModel = (abstractSql, targetDatabaseEngine) => cached_compile_1.cachedCompile('sqlModel', package_json_1.version + '+' + targetDatabaseEngine, abstractSql, () => AbstractSQLCompiler[targetDatabaseEngine].compileSchema(abstractSql));
+const generateSqlModel = (abstractSql, targetDatabaseEngine) => (0, cached_compile_1.cachedCompile)('sqlModel', package_json_1.version + '+' + targetDatabaseEngine, abstractSql, () => AbstractSQLCompiler[targetDatabaseEngine].compileSchema(abstractSql));
 exports.generateSqlModel = generateSqlModel;
-const generateModels = (model, targetDatabaseEngine) => {
-    const { apiRoot: vocab, modelText: se } = model;
+function generateModels(model, targetDatabaseEngine) {
+    const { apiRoot: vocab, modelText: se, translateTo, translations } = model;
     let { abstractSql: maybeAbstractSql } = model;
     let lf;
     if (se) {
         try {
-            lf = exports.generateLfModel(se);
+            lf = (0, exports.generateLfModel)(se);
         }
         catch (e) {
             console.error(`Error parsing model '${vocab}':`, e);
             throw new Error(`Error parsing model '${vocab}': ` + e);
         }
         try {
-            maybeAbstractSql = exports.generateAbstractSqlModel(lf);
+            maybeAbstractSql = (0, exports.generateAbstractSqlModel)(lf);
         }
         catch (e) {
             console.error(`Error translating model '${vocab}':`, e);
@@ -198,50 +240,80 @@ const generateModels = (model, targetDatabaseEngine) => {
         }
     }
     const abstractSql = maybeAbstractSql;
-    const odataMetadata = cached_compile_1.cachedCompile('metadata', odata_metadata_generator_1.generateODataMetadata.version, { vocab, abstractSqlModel: abstractSql }, () => odata_metadata_generator_1.generateODataMetadata(vocab, abstractSql));
+    const odataMetadata = (0, cached_compile_1.cachedCompile)('metadata', odata_metadata_generator_1.generateODataMetadata.version, { vocab, abstractSqlModel: abstractSql }, () => (0, odata_metadata_generator_1.generateODataMetadata)(vocab, abstractSql));
     let sql;
-    try {
-        sql = exports.generateSqlModel(abstractSql, targetDatabaseEngine);
+    let resourceRenames;
+    if (translateTo != null) {
+        resourceRenames = (0, translations_1.translateAbstractSqlModel)(abstractSql, models[translateTo].abstractSql, model.apiRoot, translateTo, translations);
     }
-    catch (e) {
-        console.error(`Error compiling model '${vocab}':`, e);
-        throw new Error(`Error compiling model '${vocab}': ` + e);
+    else {
+        for (const [key, table] of Object.entries(abstractSql.tables)) {
+            abstractSql.tables[`${key}$${model.apiRoot}`] = { ...table };
+        }
+        try {
+            sql = (0, exports.generateSqlModel)(abstractSql, targetDatabaseEngine);
+        }
+        catch (e) {
+            console.error(`Error compiling model '${vocab}':`, e);
+            throw new Error(`Error compiling model '${vocab}': ` + e);
+        }
     }
-    return { vocab, se, lf, abstractSql, sql, odataMetadata };
-};
+    return {
+        vocab,
+        translateTo,
+        resourceRenames,
+        se,
+        lf,
+        abstractSql,
+        sql,
+        odataMetadata,
+    };
+}
 exports.generateModels = generateModels;
-const executeModel = (tx, model) => exports.executeModels(tx, [model]);
+const executeModel = (tx, model) => (0, exports.executeModels)(tx, [model]);
 exports.executeModel = executeModel;
 const executeModels = async (tx, execModels) => {
     try {
         const compiledModels = await Promise.all(execModels.map(async (model) => {
-            var _a, _b, _c, _d;
             const { apiRoot } = model;
-            await migrator.run(tx, model);
-            const compiledModel = exports.generateModels(model, exports.db.engine);
-            for (const createStatement of compiledModel.sql.createSchema) {
-                const promise = tx.executeSql(createStatement);
-                if (exports.db.engine === 'websql') {
-                    promise.catch((err) => {
-                        console.warn("Ignoring errors in the create table statements for websql as it doesn't support CREATE IF NOT EXISTS", err);
-                    });
+            await syncMigrator.run(tx, model);
+            const compiledModel = generateModels(model, exports.db.engine);
+            if (compiledModel.sql) {
+                for (const createStatement of compiledModel.sql.createSchema) {
+                    const promise = tx.executeSql(createStatement);
+                    if (exports.db.engine === 'websql') {
+                        promise.catch((err) => {
+                            console.warn("Ignoring errors in the create table statements for websql as it doesn't support CREATE IF NOT EXISTS", err);
+                        });
+                    }
+                    await promise;
                 }
-                await promise;
             }
-            await migrator.postRun(tx, model);
+            await syncMigrator.postRun(tx, model);
             odataResponse.prepareModel(compiledModel.abstractSql);
             deepFreeze(compiledModel.abstractSql);
-            models[apiRoot] = compiledModel;
-            await exports.validateModel(tx, apiRoot);
+            const versions = [apiRoot];
+            if (compiledModel.translateTo != null) {
+                versions.push(...models[compiledModel.translateTo].versions);
+            }
+            models[apiRoot] = {
+                ...compiledModel,
+                versions,
+            };
+            if (compiledModel.sql) {
+                await (0, exports.validateModel)(tx, apiRoot);
+            }
             exports.api[apiRoot] = new PinejsClient('/' + apiRoot + '/');
             exports.api[apiRoot].logger = { ...console };
             if (model.logging != null) {
-                const defaultSetting = (_b = (_a = model.logging) === null || _a === void 0 ? void 0 : _a.default) !== null && _b !== void 0 ? _b : true;
+                const defaultSetting = model.logging?.default ?? true;
+                const { logger } = exports.api[apiRoot];
                 for (const k of Object.keys(model.logging)) {
                     const key = k;
-                    if (typeof exports.api[apiRoot].logger[key] === 'function' &&
-                        !((_d = (_c = model.logging) === null || _c === void 0 ? void 0 : _c[key]) !== null && _d !== void 0 ? _d : defaultSetting)) {
-                        exports.api[apiRoot].logger[key] = _.noop;
+                    if (key !== 'Console' &&
+                        typeof logger[key] === 'function' &&
+                        !(model.logging?.[key] ?? defaultSetting)) {
+                        logger[key] = _.noop;
                     }
                 }
             }
@@ -249,7 +321,6 @@ const executeModels = async (tx, execModels) => {
         }));
         await Promise.all(compiledModels.map(async (model) => {
             const updateModel = async (modelType) => {
-                var _a;
                 if (model[modelType] == null) {
                     return await exports.api.dev.delete({
                         resource: 'model',
@@ -283,10 +354,12 @@ const executeModels = async (tx, execModels) => {
                 let uri = '/dev/model';
                 const body = {
                     is_of__vocabulary: model.vocab,
-                    model_value: model[modelType],
+                    model_value: typeof model[modelType] === 'string'
+                        ? { value: model[modelType] }
+                        : model[modelType],
                     model_type: modelType,
                 };
-                const id = (_a = result === null || result === void 0 ? void 0 : result[0]) === null || _a === void 0 ? void 0 : _a.id;
+                const id = result?.[0]?.id;
                 if (id != null) {
                     uri += '(' + id + ')';
                     method = 'PATCH';
@@ -295,10 +368,13 @@ const executeModels = async (tx, execModels) => {
                 else {
                     uri += '?returnResource=false';
                 }
-                return await exports.runURI(method, uri, body, tx, permissions.root);
+                return await (0, exports.runURI)(method, uri, body, tx, permissions.root);
             };
             await Promise.all(['se', 'lf', 'abstractSql', 'sql', 'odataMetadata'].map(updateModel));
         }));
+        await Promise.all(execModels.map(async (model) => {
+            await asyncMigrator.run(tx, model);
+        }));
     }
     catch (err) {
         await Promise.all(execModels.map(async ({ apiRoot }) => {
@@ -313,23 +389,26 @@ const cleanupModel = (vocab) => {
     delete exports.api[vocab];
 };
 const deleteModel = async (vocabulary) => {
-    await exports.db.transaction(async (tx) => {
-        const dropStatements = models[vocabulary].sql.dropSchema.map((dropStatement) => tx.executeSql(dropStatement));
-        await Promise.all(dropStatements.concat([
-            exports.api.dev.delete({
-                resource: 'model',
-                passthrough: {
-                    tx,
-                    req: permissions.root,
-                },
-                options: {
-                    $filter: {
-                        is_of__vocabulary: vocabulary,
+    const { sql } = models[vocabulary];
+    if (sql) {
+        await exports.db.transaction(async (tx) => {
+            const dropStatements = sql.dropSchema.map((dropStatement) => tx.executeSql(dropStatement));
+            await Promise.all(dropStatements.concat([
+                exports.api.dev.delete({
+                    resource: 'model',
+                    passthrough: {
+                        tx,
+                        req: permissions.root,
                     },
-                },
-            }),
-        ]));
-    });
+                    options: {
+                        $filter: {
+                            is_of__vocabulary: vocabulary,
+                        },
+                    },
+                }),
+            ]));
+        });
+    }
     await cleanupModel(vocabulary);
 };
 exports.deleteModel = deleteModel;
@@ -364,7 +443,7 @@ exports.runRule = (() => {
         },
     });
     const translator = LF2AbstractSQL.LF2AbstractSQL.createInstance();
-    translator.addTypes(sbvrTypes);
+    translator.addTypes(sbvr_types_1.default);
     return async (vocab, rule) => {
         const seModel = models[vocab].se;
         const { logger } = exports.api[vocab];
@@ -440,7 +519,7 @@ exports.runRule = (() => {
         if (Array.isArray(compiledRule)) {
             throw new Error('Unexpected query generated');
         }
-        const values = await abstract_sql_1.getAndCheckBindValues({
+        const values = await (0, abstract_sql_1.getAndCheckBindValues)({
             vocabulary: vocab,
             odataBinds: [],
             values: {},
@@ -448,7 +527,7 @@ exports.runRule = (() => {
         }, compiledRule.bindings);
         const result = await exports.db.executeSql(compiledRule.query, values);
         const table = models[vocab].abstractSql.tables[resourceName];
-        const odataIdField = odata_to_abstract_sql_1.sqlNameToODataName(table.idField);
+        const odataIdField = (0, odata_to_abstract_sql_1.sqlNameToODataName)(table.idField);
         let ids = result.rows.map((row) => row[table.idField]);
         ids = _.uniq(ids);
         ids = ids.map((id) => odataIdField + ' eq ' + id);
@@ -459,10 +538,10 @@ exports.runRule = (() => {
         else {
             filter = '0 eq 1';
         }
-        const odataResult = (await exports.runURI('GET', '/' +
+        const odataResult = (await (0, exports.runURI)('GET', '/' +
             vocab +
             '/' +
-            odata_to_abstract_sql_1.sqlNameToODataName(table.resourceName) +
+            (0, odata_to_abstract_sql_1.sqlNameToODataName)(table.resourceName) +
             '?$filter=' +
             filter, undefined, undefined, permissions.rootRead));
         odataResult.__formulationType = formulationType;
@@ -472,7 +551,7 @@ exports.runRule = (() => {
 })();
 class PinejsClient extends pinejs_client_core_1.PinejsClientCore {
     async _request({ method, url, body, tx, req, custom, }) {
-        return (await exports.runURI(method, url, body, tx, req, custom));
+        return (await (0, exports.runURI)(method, url, body, tx, req, custom));
     }
 }
 exports.PinejsClient = PinejsClient;
@@ -484,7 +563,7 @@ const runURI = async (method, uri, body = {}, tx, req, custom) => {
     }
     let user;
     let apiKey;
-    if (req != null && _.isObject(req)) {
+    if (req != null && typeof req === 'object') {
         user = req.user;
         apiKey = req.apiKey;
     }
@@ -520,23 +599,26 @@ const runURI = async (method, uri, body = {}, tx, req, custom) => {
     if (_.isError(response)) {
         throw response;
     }
-    const { body: responseBody, status } = response;
-    if (status != null && status >= 400) {
-        const ErrorClass = errors_1.statusCodeToError[status];
+    const { body: responseBody, statusCode, headers } = response;
+    if (statusCode != null && statusCode >= 400) {
+        const ErrorClass = errors_1.statusCodeToError[statusCode];
         if (ErrorClass != null) {
-            throw new ErrorClass(undefined, responseBody);
+            throw new ErrorClass(undefined, responseBody, headers);
         }
-        throw new errors_1.HttpError(status, undefined, responseBody);
+        throw new errors_1.HttpError(statusCode, undefined, responseBody, headers);
     }
     return responseBody;
 };
 exports.runURI = runURI;
 const getAbstractSqlModel = (request) => {
-    var _a;
-    return ((_a = request.abstractSqlModel) !== null && _a !== void 0 ? _a : (request.abstractSqlModel = models[request.vocabulary].abstractSql));
+    return (request.abstractSqlModel ??= models[request.vocabulary].abstractSql);
 };
 exports.getAbstractSqlModel = getAbstractSqlModel;
-const getIdField = (request) => exports.getAbstractSqlModel(request).tables[exports.resolveSynonym(request)].idField;
+const getFinalAbstractSqlModel = (request) => {
+    const finalModel = _.last(request.translateVersions);
+    return (request.finalAbstractSqlModel ??= models[finalModel].abstractSql);
+};
+const getIdField = (request) => getFinalAbstractSqlModel(request).tables[(0, exports.resolveSynonym)(request)].idField;
 const getAffectedIds = async (args) => {
     const { request } = args;
     if (request.affectedIds) {
@@ -552,38 +634,38 @@ const getAffectedIds = async (args) => {
 };
 exports.getAffectedIds = getAffectedIds;
 const $getAffectedIds = async ({ req, request, tx, }) => {
-    var _a;
-    var _b;
     if (!['PATCH', 'DELETE'].includes(request.method)) {
         throw new Error('Can only call `getAffectedIds` with PATCH/DELETE requests');
     }
-    request = await uriParser.parseOData({
+    const parsedRequest = await uriParser.parseOData({
         method: request.method,
         url: `/${request.vocabulary}${request.url}`,
     });
-    request.engine = exports.db.engine;
-    const abstractSqlModel = exports.getAbstractSqlModel(request);
-    const resourceName = exports.resolveSynonym(request);
+    parsedRequest.engine = request.engine;
+    parsedRequest.translateVersions = request.translateVersions;
+    let affectedRequest = parsedRequest;
+    const abstractSqlModel = (0, exports.getAbstractSqlModel)(affectedRequest);
+    const resourceName = (0, exports.resolveSynonym)(affectedRequest);
     const resourceTable = abstractSqlModel.tables[resourceName];
     if (resourceTable == null) {
-        throw new Error('Unknown resource: ' + request.resourceName);
+        throw new Error('Unknown resource: ' + affectedRequest.resourceName);
     }
     const { idField } = resourceTable;
-    (_a = (_b = request.odataQuery).options) !== null && _a !== void 0 ? _a : (_b.options = {});
-    request.odataQuery.options.$select = {
+    affectedRequest.odataQuery.options ??= {};
+    affectedRequest.odataQuery.options.$select = {
         properties: [{ name: idField }],
     };
-    delete request.odataQuery.options.$expand;
-    await permissions.addPermissions(req, request);
-    request.method = 'GET';
-    request = uriParser.translateUri(request);
-    request = abstract_sql_1.compileRequest(request);
+    delete affectedRequest.odataQuery.options.$expand;
+    await permissions.addPermissions(req, affectedRequest);
+    affectedRequest.method = 'GET';
+    affectedRequest = uriParser.translateUri(affectedRequest);
+    affectedRequest = (0, abstract_sql_1.compileRequest)(affectedRequest);
     let result;
     if (tx != null) {
-        result = await runQuery(tx, request);
+        result = await runQuery(tx, affectedRequest);
     }
     else {
-        result = await runTransaction(req, (newTx) => runQuery(newTx, request));
+        result = await runTransaction(req, affectedRequest, (newTx) => runQuery(newTx, affectedRequest));
     }
     return result.rows.map((row) => row[idField]);
 };
@@ -591,10 +673,14 @@ const runODataRequest = (req, vocabulary) => {
     if (module_1.env.DEBUG) {
         exports.api[vocabulary].logger.log('Parsing', req.method, req.url);
     }
-    const reqHooks = hooks_1.getHooks({
-        method: req.method,
-        vocabulary,
-    });
+    const { versions } = models[vocabulary];
+    const reqHooks = versions.map((version) => [
+        version,
+        (0, hooks_1.getHooks)({
+            method: req.method,
+            vocabulary: version,
+        }, version === versions[0]),
+    ]);
     const transactions = [];
     const tryCancelRequest = () => {
         transactions.forEach(async (tx) => {
@@ -604,22 +690,22 @@ const runODataRequest = (req, vocabulary) => {
             try {
                 await tx.rollback();
             }
-            catch (_a) {
+            catch {
             }
         });
         transactions.length = 0;
-        hooks_1.rollbackRequestHooks(reqHooks);
+        (0, hooks_1.rollbackRequestHooks)(reqHooks);
     };
     req.on('close', tryCancelRequest);
     if (req.tx != null) {
         transactions.push(req.tx);
         req.tx.on('rollback', tryCancelRequest);
     }
-    const mapSeries = controlFlow.getMappingFn(req.headers);
+    const mappingFn = controlFlow.getMappingFn(req.headers);
     return {
         tryCancelRequest,
         promise: (async () => {
-            await hooks_1.runHooks('PREPARSE', reqHooks, { req, tx: req.tx });
+            await (0, hooks_1.runHooks)('PREPARSE', reqHooks, { req, tx: req.tx });
             let requests;
             if (req.batch != null && req.batch.length > 0) {
                 requests = req.batch;
@@ -628,43 +714,64 @@ const runODataRequest = (req, vocabulary) => {
                 const { method, url, body } = req;
                 requests = [{ method, url, data: body }];
             }
-            const prepareRequest = async ($request) => {
-                $request.engine = exports.db.engine;
-                $request.hooks = hooks_1.getHooks($request);
+            const prepareRequest = async (parsedRequest) => {
+                parsedRequest.engine = exports.db.engine;
+                parsedRequest.translateVersions = [...versions];
+                const $request = parsedRequest;
                 try {
-                    await hooks_1.runHooks('POSTPARSE', $request.hooks, {
-                        req,
-                        request: $request,
-                        tx: req.tx,
-                    });
+                    $request.hooks = [];
+                    for (const version of versions) {
+                        const hooks = [
+                            version,
+                            (0, hooks_1.getHooks)({
+                                resourceName: $request.resourceName,
+                                vocabulary: version,
+                                method: $request.method,
+                            }, version === versions[0]),
+                        ];
+                        $request.hooks.push(hooks);
+                        await (0, hooks_1.runHooks)('POSTPARSE', [hooks], {
+                            req,
+                            request: $request,
+                            tx: req.tx,
+                        });
+                        const { resourceRenames } = models[version];
+                        if (resourceRenames) {
+                            const resourceName = (0, exports.resolveSynonym)($request);
+                            if (resourceRenames[resourceName]) {
+                                $request.resourceName = (0, odata_to_abstract_sql_1.sqlNameToODataName)(resourceRenames[resourceName]);
+                            }
+                        }
+                    }
                     const translatedRequest = await uriParser.translateUri($request);
-                    return await abstract_sql_1.compileRequest(translatedRequest);
+                    return await (0, abstract_sql_1.compileRequest)(translatedRequest);
                 }
                 catch (err) {
-                    hooks_1.rollbackRequestHooks(reqHooks);
-                    hooks_1.rollbackRequestHooks($request.hooks);
+                    (0, hooks_1.rollbackRequestHooks)(reqHooks);
+                    (0, hooks_1.rollbackRequestHooks)($request.hooks);
                     throw err;
                 }
             };
-            const results = await mapSeries(requests, async (requestPart) => {
-                let request = await uriParser.parseOData(requestPart);
-                if (Array.isArray(request)) {
-                    request = await Bluebird.mapSeries(request, prepareRequest);
+            const results = await mappingFn(requests, async (requestPart) => {
+                const parsedRequest = await uriParser.parseOData(requestPart);
+                let request;
+                if (Array.isArray(parsedRequest)) {
+                    request = await controlFlow.mapSeries(parsedRequest, prepareRequest);
                 }
                 else {
-                    request = await prepareRequest(request);
+                    request = await prepareRequest(parsedRequest);
                 }
-                return await runTransaction(req, async (tx) => {
+                return await runTransaction(req, request, async (tx) => {
                     transactions.push(tx);
                     tx.on('rollback', () => {
-                        hooks_1.rollbackRequestHooks(reqHooks);
+                        (0, hooks_1.rollbackRequestHooks)(reqHooks);
                         if (Array.isArray(request)) {
-                            request.forEach(({ hooks }) => {
-                                hooks_1.rollbackRequestHooks(hooks);
-                            });
+                            for (const { hooks } of request) {
+                                (0, hooks_1.rollbackRequestHooks)(hooks);
+                            }
                         }
                         else {
-                            hooks_1.rollbackRequestHooks(request.hooks);
+                            (0, hooks_1.rollbackRequestHooks)(request.hooks);
                         }
                     });
                     if (Array.isArray(request)) {
@@ -687,7 +794,7 @@ const runODataRequest = (req, vocabulary) => {
                 else {
                     if (!Array.isArray(result) &&
                         result.body == null &&
-                        result.status == null) {
+                        result.statusCode == null) {
                         console.error('No status or body set', req.url, responses);
                         return new errors_1.InternalRequestError();
                     }
@@ -710,36 +817,15 @@ const handleODataRequest = async (req, res, next) => {
         res.set('Cache-Control', 'no-cache');
         if (req.batch == null || req.batch.length === 0) {
             let [response] = responses;
-            if (_.isError(response)) {
-                response = {
-                    status: response.status,
-                    body: response.getResponseBody(),
-                };
-            }
-            const { body, headers, status } = response;
-            if (status) {
-                res.status(status);
-            }
-            _.forEach(headers, (headerValue, headerName) => {
-                res.set(headerName, headerValue);
-            });
-            if (!body) {
-                res.sendStatus(status);
-            }
-            else {
-                if (status != null) {
-                    res.status(status);
-                }
-                res.json(body);
+            if (response instanceof errors_1.HttpError) {
+                response = httpErrorToResponse(response);
             }
+            handleResponse(res, response);
         }
         else {
             res.status(200).sendMulti(responses.map((response) => {
-                if (_.isError(response)) {
-                    return {
-                        status: response.status,
-                        body: response.getResponseBody(),
-                    };
+                if (response instanceof errors_1.HttpError) {
+                    response = httpErrorToResponse(response);
                 }
                 else {
                     return response;
@@ -748,21 +834,49 @@ const handleODataRequest = async (req, res, next) => {
         }
     }
     catch (e) {
-        if (e instanceof errors_1.HttpError) {
-            const body = e.getResponseBody();
-            if (body) {
-                res.status(e.status).send(body);
-            }
-            else {
-                res.sendStatus(e.status);
-            }
+        if ((0, exports.handleHttpErrors)(req, res, e)) {
             return;
         }
         console.error('An error occurred while constructing the response', e);
-        res.sendStatus(500);
+        res.status(500).end();
     }
 };
 exports.handleODataRequest = handleODataRequest;
+const handleErrorFns = [];
+const onHandleHttpError = (fn) => {
+    handleErrorFns.push(fn);
+};
+exports.onHandleHttpError = onHandleHttpError;
+const handleHttpErrors = (req, res, err) => {
+    if (err instanceof errors_1.HttpError) {
+        for (const handleErrorFn of handleErrorFns) {
+            handleErrorFn(req, err);
+        }
+        const response = httpErrorToResponse(err);
+        handleResponse(res, response);
+        return true;
+    }
+    return false;
+};
+exports.handleHttpErrors = handleHttpErrors;
+const handleResponse = (res, response) => {
+    const { body, headers, statusCode } = response;
+    res.set(headers);
+    res.status(statusCode);
+    if (!body) {
+        res.end();
+    }
+    else {
+        res.json(body);
+    }
+};
+const httpErrorToResponse = (err) => {
+    return {
+        statusCode: err.status,
+        body: err.getResponseBody(),
+        headers: err.headers,
+    };
+};
 const convertToHttpError = (err) => {
     if (err instanceof errors_1.HttpError) {
         return err;
@@ -794,7 +908,7 @@ const runRequest = async (req, tx, request) => {
     let result;
     try {
         try {
-            await hooks_1.runHooks('PRERUN', request.hooks, { req, request, tx });
+            await (0, hooks_1.runHooks)('PRERUN', request.hooks, { req, request, tx });
             switch (request.method) {
                 case 'GET':
                     result = await runGet(req, request, tx);
@@ -831,10 +945,10 @@ const runRequest = async (req, tx, request) => {
             }
             throw err;
         }
-        await hooks_1.runHooks('POSTRUN', request.hooks, { req, request, result, tx });
+        await (0, hooks_1.runHooks)('POSTRUN', request.hooks, { req, request, result, tx });
     }
     catch (err) {
-        await hooks_1.runHooks('POSTRUN-ERROR', request.hooks, {
+        await (0, hooks_1.runHooks)('POSTRUN-ERROR', request.hooks, {
             req,
             request,
             tx,
@@ -845,30 +959,29 @@ const runRequest = async (req, tx, request) => {
     return await prepareResponse(req, request, result, tx);
 };
 const runChangeSet = (req, tx) => async (changeSetResults, request) => {
-    var _a;
     request = updateBinds(changeSetResults, request);
     const result = await runRequest(req, tx, request);
     if (request.id == null) {
         throw new Error('No request id');
     }
-    (_a = result.headers) !== null && _a !== void 0 ? _a : (result.headers = {});
-    result.headers['Content-Id'] = request.id;
+    result.headers ??= {};
+    result.headers['content-id'] = request.id;
     changeSetResults.set(request.id, result);
 };
 const updateBinds = (changeSetResults, request) => {
     if (request._defer) {
-        request.odataBinds = request.odataBinds.map(([tag, id]) => {
+        for (let i = 0; i < request.odataBinds.length; i++) {
+            const [tag, id] = request.odataBinds[i];
             if (tag === 'ContentReference') {
                 const ref = changeSetResults.get(id);
-                if ((ref === null || ref === void 0 ? void 0 : ref.body) == null ||
+                if (ref?.body == null ||
                     typeof ref.body === 'string' ||
                     ref.body.id === undefined) {
                     throw new errors_1.BadRequestError('Reference to a non existing resource in Changeset');
                 }
-                return uriParser.parseId(ref.body.id);
+                request.odataBinds[i] = uriParser.parseId(ref.body.id);
             }
-            return [tag, id];
-        });
+        }
     }
     return request;
 };
@@ -890,15 +1003,33 @@ const prepareResponse = async (req, request, result, tx) => {
             throw new errors_1.MethodNotAllowedError();
     }
 };
-const runTransaction = async (req, callback) => {
+const checkReadOnlyRequests = (request) => {
+    if (request.method !== 'GET') {
+        return false;
+    }
+    const { hooks } = request;
+    if (hooks == null) {
+        return true;
+    }
+    return hooks.every(([, versionedHooks]) => Object.values(versionedHooks).every((hookTypeHooks) => {
+        return (hookTypeHooks == null || hookTypeHooks.every((hook) => hook.readOnlyTx));
+    }));
+};
+const runTransaction = async (req, request, callback) => {
     if (req.tx != null) {
         return await callback(req.tx);
     }
-    else {
-        return await exports.db.transaction(callback);
+    if (Array.isArray(request)) {
+        if (request.every(checkReadOnlyRequests)) {
+            return await exports.db.readTransaction(callback);
+        }
+    }
+    else if (checkReadOnlyRequests(request)) {
+        return await exports.db.readTransaction(callback);
     }
+    return await exports.db.transaction(callback);
 };
-const runQuery = async (tx, request, queryIndex, returningIdField) => {
+const runQuery = async (tx, request, queryIndex, addReturning = false) => {
     const { vocabulary } = request;
     let { sqlQuery } = request;
     if (sqlQuery == null) {
@@ -914,13 +1045,14 @@ const runQuery = async (tx, request, queryIndex, returningIdField) => {
         sqlQuery = sqlQuery[queryIndex];
     }
     const { query, bindings } = sqlQuery;
-    const values = await abstract_sql_1.getAndCheckBindValues(request, bindings);
+    const values = await (0, abstract_sql_1.getAndCheckBindValues)(request, bindings);
     if (module_1.env.DEBUG) {
         exports.api[vocabulary].logger.log(query, values);
     }
+    const returningIdField = addReturning && request.affectedIds == null ? getIdField(request) : false;
     const sqlResult = await tx.executeSql(query, values, returningIdField);
     if (returningIdField) {
-        request.affectedIds = sqlResult.rows.map((row) => row[returningIdField]);
+        request.affectedIds ??= sqlResult.rows.map((row) => row[returningIdField]);
     }
     return sqlResult;
 };
@@ -930,117 +1062,123 @@ const runGet = async (_req, request, tx) => {
     }
 };
 const respondGet = async (req, request, result, tx) => {
-    var _a;
     const vocab = request.vocabulary;
     if (request.sqlQuery != null) {
-        const format = (_a = request.odataQuery.options) === null || _a === void 0 ? void 0 : _a.$format;
+        const format = request.odataQuery.options?.$format;
         const metadata = format != null && typeof format === 'object'
             ? format.metadata
             : undefined;
-        const d = await odataResponse.process(vocab, exports.getAbstractSqlModel(request), request.resourceName, result.rows, { includeMetadata: metadata === 'full' });
-        await hooks_1.runHooks('PRERESPOND', request.hooks, {
+        const d = await odataResponse.process(vocab, (0, exports.getAbstractSqlModel)(request), request.originalResourceName, result.rows, { includeMetadata: metadata === 'full' });
+        const response = {
+            statusCode: 200,
+            body: { d },
+            headers: { 'content-type': 'application/json' },
+        };
+        await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
             req,
             request,
             result,
-            data: d,
+            response,
             tx,
         });
-        return { body: { d }, headers: { contentType: 'application/json' } };
+        return response;
     }
     else {
         if (request.resourceName === '$metadata') {
             return {
+                statusCode: 200,
                 body: models[vocab].odataMetadata,
-                headers: { contentType: 'xml' },
+                headers: { 'content-type': 'xml' },
             };
         }
         else {
             return {
-                status: 404,
+                statusCode: 404,
             };
         }
     }
 };
 const runPost = async (_req, request, tx) => {
-    const { rowsAffected, insertId } = await runQuery(tx, request, undefined, getIdField(request));
+    const { rowsAffected, insertId } = await runQuery(tx, request, undefined, true);
     if (rowsAffected === 0) {
         throw new errors_1.PermissionError();
     }
-    await exports.validateModel(tx, request.vocabulary, request);
+    await (0, exports.validateModel)(tx, _.last(request.translateVersions), request);
     return insertId;
 };
 const respondPost = async (req, request, id, tx) => {
-    var _a, _b;
     const vocab = request.vocabulary;
-    const location = odataResponse.resourceURI(vocab, request.resourceName, id);
+    const location = odataResponse.resourceURI(vocab, request.originalResourceName, id);
     if (module_1.env.DEBUG) {
         exports.api[vocab].logger.log('Insert ID: ', request.resourceName, id);
     }
     let result = { d: [{ id }] };
     if (location != null &&
-        !['0', 'false'].includes((_b = (_a = request === null || request === void 0 ? void 0 : request.odataQuery) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.returnResource)) {
+        !['0', 'false'].includes(request?.odataQuery?.options?.returnResource)) {
         try {
-            result = (await exports.runURI('GET', location, undefined, tx, req));
+            result = (await (0, exports.runURI)('GET', location, undefined, tx, req));
         }
-        catch (_c) {
+        catch {
         }
     }
-    await hooks_1.runHooks('PRERESPOND', request.hooks, {
+    const response = {
+        statusCode: 201,
+        body: result.d[0],
+        headers: {
+            'content-type': 'application/json',
+            location,
+        },
+    };
+    await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
         req,
         request,
         result,
+        response,
         tx,
     });
-    return {
-        status: 201,
-        body: result.d[0],
-        headers: {
-            contentType: 'application/json',
-            Location: location,
-        },
-    };
+    return response;
 };
 const runPut = async (_req, request, tx) => {
-    const idField = getIdField(request);
     let rowsAffected;
     if (Array.isArray(request.sqlQuery)) {
-        ({ rowsAffected } = await runQuery(tx, request, 1, idField));
+        ({ rowsAffected } = await runQuery(tx, request, 1, true));
         if (rowsAffected === 0) {
-            ({ rowsAffected } = await runQuery(tx, request, 0, idField));
+            ({ rowsAffected } = await runQuery(tx, request, 0, true));
         }
     }
     else {
-        ({ rowsAffected } = await runQuery(tx, request, undefined, idField));
+        ({ rowsAffected } = await runQuery(tx, request, undefined, true));
     }
     if (rowsAffected > 0) {
-        await exports.validateModel(tx, request.vocabulary, request);
+        await (0, exports.validateModel)(tx, _.last(request.translateVersions), request);
     }
     return undefined;
 };
 const respondPut = async (req, request, result, tx) => {
-    await hooks_1.runHooks('PRERESPOND', request.hooks, {
+    const response = {
+        statusCode: 200,
+    };
+    await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
         req,
         request,
         result,
+        response,
         tx,
     });
-    return {
-        status: 200,
-        headers: {},
-    };
+    return response;
 };
 const respondDelete = respondPut;
 const respondOptions = respondPut;
 const runDelete = async (_req, request, tx) => {
-    const { rowsAffected } = await runQuery(tx, request, undefined, getIdField(request));
+    const { rowsAffected } = await runQuery(tx, request, undefined, true);
     if (rowsAffected > 0) {
-        await exports.validateModel(tx, request.vocabulary, request);
+        await (0, exports.validateModel)(tx, _.last(request.translateVersions), request);
     }
     return undefined;
 };
 const executeStandardModels = async (tx) => {
     try {
-        await exports.executeModel(tx, {
+        await (0, exports.executeModel)(tx, {
             apiRoot: 'dev',
             modelText: devModel,
             logging: {
@@ -1051,9 +1189,33 @@ const executeStandardModels = async (tx) => {
 					ALTER TABLE "model"
 					ADD COLUMN IF NOT EXISTS "modified at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL;
 				`,
+                '15.0.0-data-types': async ($tx, sbvrUtils) => {
+                    switch (sbvrUtils.db.engine) {
+                        case 'mysql':
+                            await $tx.executeSql(`\
+								ALTER TABLE "model"
+								MODIFY "model value" JSON NOT NULL;
+
+								UPDATE "model"
+								SET "model value" = CAST('{"value":' || CAST("model value" AS CHAR) || '}' AS JSON)
+								WHERE "model type" IN ('se', 'odataMetadata')
+								AND CAST("model value" AS CHAR) LIKE '"%';`);
+                            break;
+                        case 'postgres':
+                            await $tx.executeSql(`\
+								ALTER TABLE "model"
+								ALTER COLUMN "model value" SET DATA TYPE JSONB USING "model value"::JSONB;
+
+								UPDATE "model"
+								SET "model value" = CAST('{"value":' || CAST("model value" AS TEXT) || '}' AS JSON)
+								WHERE "model type" IN ('se', 'odataMetadata')
+								AND CAST("model value" AS TEXT) LIKE '"%';`);
+                            break;
+                    }
+                },
             },
         });
-        await exports.executeModels(tx, permissions.config.models);
+        await (0, exports.executeModels)(tx, permissions.config.models);
         console.info('Successfully executed standard models.');
     }
     catch (err) {
@@ -1066,7 +1228,7 @@ const setup = async (_app, $db) => {
     exports.db = exports.db = $db;
     try {
         await exports.db.transaction(async (tx) => {
-            await exports.executeStandardModels(tx);
+            await (0, exports.executeStandardModels)(tx);
             await permissions.setup();
         });
     }
@@ -1077,7 +1239,7 @@ const setup = async (_app, $db) => {
     try {
         await exports.db.executeSql('CREATE UNIQUE INDEX "uniq_model_model_type_vocab" ON "model" ("is of-vocabulary", "model type");');
     }
-    catch (_a) {
+    catch {
     }
 };
 exports.setup = setup;