@balena/pinejs 19.7.2-build-esm-debc5e08e09b78ba96aec7ee219676236007e113-1 → 19.7.2-build-update-deps-a909ee054f395de407ec4e1275fd0f5b7514fe29-1

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

@@ -1,45 +1,84 @@
-import _ from 'lodash';
-import { cachedCompile } from './cached-compile.js';
-import * as AbstractSQLCompiler from '@balena/abstract-sql-compiler';
-import AbstractSqlCompilerPackage from '@balena/abstract-sql-compiler/package.json' with { type: 'json' };
-const { version: AbstractSQLCompilerVersion } = AbstractSqlCompilerPackage;
-import LF2AbstractSQL from '@balena/lf-to-abstract-sql';
-import { odataNameToSqlName, sqlNameToODataName, } from '@balena/odata-to-abstract-sql';
-import $sbvrTypes from '@balena/sbvr-types';
-const { default: sbvrTypes } = $sbvrTypes;
-import deepFreeze from 'deep-freeze';
-import { PinejsClientCore } from 'pinejs-client-core';
-import { ExtendedSBVRParser } from '../extended-sbvr-parser/extended-sbvr-parser.js';
-import * as asyncMigrator from '../migrator/async.js';
-import * as syncMigrator from '../migrator/sync.js';
-import { generateODataMetadata } from '../odata-metadata/odata-metadata-generator.js';
-import { importSBVR } from '../server-glue/sbvr-loader.js';
-const devModel = await importSBVR('./dev.sbvr', import.meta);
-import * as permissions from './permissions.js';
-import { BadRequestError, ConflictError, HttpError, InternalRequestError, MethodNotAllowedError, ParsingError, PermissionError, PermissionParsingError, SbvrValidationError, SqlCompilationError, statusCodeToError, TranslationError, UnauthorizedError, } from './errors.js';
-import * as uriParser from './uri-parser.js';
-import { rollbackRequestHooks, getHooks, runHooks, } from './hooks.js';
-export { addPureHook, addSideEffectHook, } from './hooks.js';
-import memoizeWeak from 'memoizee/weak.js';
-import * as controlFlow from './control-flow.js';
-export let db = undefined;
-export { sbvrTypes };
-import LF2AbstractSQLPackage from '@balena/lf-to-abstract-sql/package.json' with { type: 'json' };
-const { version: LF2AbstractSQLVersion } = LF2AbstractSQLPackage;
-import SbvrTypesPackage from '@balena/sbvr-types/package.json' with { type: 'json' };
-const { version: sbvrTypesVersion } = SbvrTypesPackage;
-import { compileRequest, getAndCheckBindValues, isRuleAffected, } from './abstract-sql.js';
-export { resolveOdataBind } from './abstract-sql.js';
-import * as odataResponse from './odata-response.js';
-import { env } from '../server-glue/module.js';
-import { translateAbstractSqlModel } from './translations.js';
-import { setExecutedMigrations, } from '../migrator/utils.js';
-const LF2AbstractSQLTranslator = LF2AbstractSQL.createTranslator(sbvrTypes);
-const LF2AbstractSQLTranslatorVersion = `${LF2AbstractSQLVersion}+${sbvrTypesVersion}`;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postSetup = exports.setup = exports.executeStandardModels = exports.handleHttpErrors = exports.onHandleHttpError = exports.handleODataRequest = exports.getApiRoot = exports.getModel = exports.getAffectedIds = exports.getAbstractSqlModel = exports.runURI = exports.logger = exports.api = exports.PinejsClient = exports.runRule = exports.getID = exports.deleteModel = exports.postExecuteModels = exports.executeModels = exports.executeModel = 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;
+exports.generateModels = generateModels;
+const lodash_1 = __importDefault(require("lodash"));
+const cached_compile_1 = require("./cached-compile");
+const AbstractSQLCompiler = __importStar(require("@balena/abstract-sql-compiler"));
+const package_json_1 = require("@balena/abstract-sql-compiler/package.json");
+const LF2AbstractSQL = __importStar(require("@balena/lf-to-abstract-sql"));
+const odata_to_abstract_sql_1 = require("@balena/odata-to-abstract-sql");
+const sbvr_types_1 = __importDefault(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 asyncMigrator = __importStar(require("../migrator/async"));
+const syncMigrator = __importStar(require("../migrator/sync"));
+const odata_metadata_generator_1 = require("../odata-metadata/odata-metadata-generator");
+const sbvr_loader_1 = require("../server-glue/sbvr-loader");
+const devModel = (0, sbvr_loader_1.requireSBVR)('./dev.sbvr', require);
+const permissions = __importStar(require("./permissions"));
+const errors_1 = require("./errors");
+const uriParser = __importStar(require("./uri-parser"));
+const hooks_1 = require("./hooks");
+var hooks_2 = require("./hooks");
+Object.defineProperty(exports, "addPureHook", { enumerable: true, get: function () { return hooks_2.addPureHook; } });
+Object.defineProperty(exports, "addSideEffectHook", { enumerable: true, get: function () { return hooks_2.addSideEffectHook; } });
+const weak_1 = __importDefault(require("memoizee/weak"));
+const controlFlow = __importStar(require("./control-flow"));
+exports.db = undefined;
+const package_json_2 = require("@balena/lf-to-abstract-sql/package.json");
+const package_json_3 = require("@balena/sbvr-types/package.json");
+const abstract_sql_1 = require("./abstract-sql");
+var abstract_sql_2 = require("./abstract-sql");
+Object.defineProperty(exports, "resolveOdataBind", { enumerable: true, get: function () { return abstract_sql_2.resolveOdataBind; } });
+const odataResponse = __importStar(require("./odata-response"));
+const module_1 = require("../server-glue/module");
+const translations_1 = require("./translations");
+const utils_1 = require("../migrator/utils");
+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 = odataNameToSqlName(resourceName);
-    return _(sqlName)
+const memoizedResolvedSynonym = (0, weak_1.default)((abstractSqlModel, resourceName) => {
+    const sqlName = (0, odata_to_abstract_sql_1.odataNameToSqlName)(resourceName);
+    return (0, lodash_1.default)(sqlName)
         .split('-')
         .map((namePart) => {
         const synonym = abstractSqlModel.synonyms[namePart];
@@ -50,41 +89,43 @@ const memoizedResolvedSynonym = memoizeWeak((abstractSqlModel, resourceName) =>
     })
         .join('-');
 }, { primitive: true });
-export const resolveSynonym = (request) => {
-    const abstractSqlModel = getAbstractSqlModel(request);
+const resolveSynonym = (request) => {
+    const abstractSqlModel = (0, exports.getAbstractSqlModel)(request);
     return memoizedResolvedSynonym(abstractSqlModel, request.resourceName);
 };
-const memoizedResolveNavigationResource = memoizeWeak((abstractSqlModel, resourceName, navigationName) => {
-    const navigation = odataNameToSqlName(navigationName)
+exports.resolveSynonym = resolveSynonym;
+const memoizedResolveNavigationResource = (0, weak_1.default)((abstractSqlModel, resourceName, navigationName) => {
+    const navigation = (0, odata_to_abstract_sql_1.odataNameToSqlName)(navigationName)
         .split('-')
         .flatMap((namePart) => memoizedResolvedSynonym(abstractSqlModel, namePart).split('-'));
     navigation.push('$');
     const resolvedResourceName = memoizedResolvedSynonym(abstractSqlModel, resourceName);
-    const mapping = _.get(abstractSqlModel.relationships[resolvedResourceName], navigation);
+    const mapping = lodash_1.default.get(abstractSqlModel.relationships[resolvedResourceName], navigation);
     if (mapping == null) {
         throw new Error(`Cannot navigate from '${resourceName}' to '${navigationName}'`);
     }
     if (mapping.length < 2) {
         throw new Error(`'${resourceName}' to '${navigationName}' is a field not a navigation`);
     }
-    return sqlNameToODataName(abstractSqlModel.tables[mapping[1][0]].name);
+    return (0, odata_to_abstract_sql_1.sqlNameToODataName)(abstractSqlModel.tables[mapping[1][0]].name);
 }, { primitive: true });
-export const resolveNavigationResource = (request, navigationName) => {
-    const abstractSqlModel = getAbstractSqlModel(request);
+const resolveNavigationResource = (request, navigationName) => {
+    const abstractSqlModel = (0, exports.getAbstractSqlModel)(request);
     return memoizedResolveNavigationResource(abstractSqlModel, request.resourceName, navigationName);
 };
+exports.resolveNavigationResource = resolveNavigationResource;
 const prettifyConstraintError = (err, request) => {
-    if (err instanceof db.ConstraintError) {
+    if (err instanceof exports.db.ConstraintError) {
         let keyMatches = null;
         let violatedConstraintInfo;
-        if (err instanceof db.UniqueConstraintError) {
-            switch (db.engine) {
+        if (err instanceof exports.db.UniqueConstraintError) {
+            switch (exports.db.engine) {
                 case 'mysql':
                     keyMatches =
                         /ER_DUP_ENTRY: Duplicate entry '.*?[^\\]' for key '(.*?[^\\])'/.exec(err.message);
                     break;
                 case 'postgres': {
-                    const resourceName = resolveSynonym(request);
+                    const resourceName = (0, exports.resolveSynonym)(request);
                     const abstractSqlModel = getFinalAbstractSqlModel(request);
                     const table = abstractSqlModel.tables[resourceName];
                     keyMatches = new RegExp('"' + table.name + '_(.*?)_key"').exec(err.message);
@@ -102,30 +143,30 @@ const prettifyConstraintError = (err, request) => {
             }
             if (keyMatches != null) {
                 const columns = keyMatches[1].split('_');
-                throw new db.UniqueConstraintError('"' +
-                    columns.map(sqlNameToODataName).join('" and "') +
+                throw new exports.db.UniqueConstraintError('"' +
+                    columns.map(odata_to_abstract_sql_1.sqlNameToODataName).join('" and "') +
                     '" must be unique.');
             }
             if (violatedConstraintInfo != null) {
                 const { table, name: violatedConstraintName } = violatedConstraintInfo;
                 const violatedUniqueIndex = table.indexes.find((idx) => idx.name === violatedConstraintName);
                 if (violatedUniqueIndex?.description != null) {
-                    throw new BadRequestError(violatedUniqueIndex.description);
+                    throw new errors_1.BadRequestError(violatedUniqueIndex.description);
                 }
             }
-            throw new db.UniqueConstraintError('Unique key constraint violated');
+            throw new exports.db.UniqueConstraintError('Unique key constraint violated');
         }
-        if (err instanceof db.ExclusionConstraintError) {
-            throw new db.ExclusionConstraintError('Exclusion constraint violated');
+        if (err instanceof exports.db.ExclusionConstraintError) {
+            throw new exports.db.ExclusionConstraintError('Exclusion constraint violated');
         }
-        if (err instanceof db.ForeignKeyConstraintError) {
-            switch (db.engine) {
+        if (err instanceof exports.db.ForeignKeyConstraintError) {
+            switch (exports.db.engine) {
                 case 'mysql':
                     keyMatches =
                         /ER_ROW_IS_REFERENCED_: Cannot delete or update a parent row: a foreign key constraint fails \(".*?"\.(".*?").*/.exec(err.message);
                     break;
                 case 'postgres': {
-                    const resourceName = resolveSynonym(request);
+                    const resourceName = (0, exports.resolveSynonym)(request);
                     const abstractSqlModel = getFinalAbstractSqlModel(request);
                     const tableName = abstractSqlModel.tables[resourceName].name;
                     keyMatches = new RegExp('"' +
@@ -142,16 +183,16 @@ const prettifyConstraintError = (err, request) => {
                 }
             }
             if (keyMatches == null) {
-                throw new db.ForeignKeyConstraintError('Foreign key constraint violated');
+                throw new exports.db.ForeignKeyConstraintError('Foreign key constraint violated');
             }
-            throw new db.ForeignKeyConstraintError('Data is referenced by ' + sqlNameToODataName(keyMatches[1]) + '.');
+            throw new exports.db.ForeignKeyConstraintError('Data is referenced by ' + (0, odata_to_abstract_sql_1.sqlNameToODataName)(keyMatches[1]) + '.');
         }
-        if (err instanceof db.CheckConstraintError) {
-            const resourceName = resolveSynonym(request);
+        if (err instanceof exports.db.CheckConstraintError) {
+            const resourceName = (0, exports.resolveSynonym)(request);
             const abstractSqlModel = getFinalAbstractSqlModel(request);
             const table = abstractSqlModel.tables[resourceName];
             if (table.checks) {
-                switch (db.engine) {
+                switch (exports.db.engine) {
                     case 'postgres':
                         keyMatches = new RegExp('new row for relation "' +
                             table.name +
@@ -163,17 +204,17 @@ const prettifyConstraintError = (err, request) => {
                 const checkName = keyMatches[1];
                 const check = table.checks.find((c) => c.name === checkName);
                 if (check?.description != null) {
-                    throw new BadRequestError(check.description);
+                    throw new errors_1.BadRequestError(check.description);
                 }
             }
-            throw new BadRequestError('Check constraint violated');
+            throw new errors_1.BadRequestError('Check constraint violated');
         }
         err.message = 'Constraint failed';
         throw err;
     }
 };
 let cachedIsModelNew;
-export const isModelNew = async (tx, modelName) => {
+const isModelNew = async (tx, modelName) => {
     const result = await tx.tableList("name = 'model'");
     if (result.rows.length === 0) {
         return true;
@@ -184,11 +225,12 @@ export const isModelNew = async (tx, modelName) => {
     }
     return !cachedIsModelNew.has(modelName);
 };
+exports.isModelNew = isModelNew;
 const bindsForAffectedIds = (bindings, request) => {
     if (request?.affectedIds == null) {
         return {};
     }
-    const tableName = getAbstractSqlModel(request).tables[resolveSynonym(request)].name;
+    const tableName = (0, exports.getAbstractSqlModel)(request).tables[(0, exports.resolveSynonym)(request)].name;
     const isDelete = request.method === 'DELETE';
     const odataBinds = {};
     for (const bind of bindings) {
@@ -207,45 +249,49 @@ const bindsForAffectedIds = (bindings, request) => {
     }
     return odataBinds;
 };
-export const validateModel = async (tx, modelName, request) => {
+const validateModel = async (tx, modelName, 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 (!isRuleAffected(rule, request)) {
+        if (!(0, abstract_sql_1.isRuleAffected)(rule, request)) {
             return;
         }
-        const values = await getAndCheckBindValues({
+        const values = await (0, abstract_sql_1.getAndCheckBindValues)({
             vocabulary: modelName,
             odataBinds: bindsForAffectedIds(rule.bindings, request),
             values: {},
-            engine: db.engine,
+            engine: exports.db.engine,
         }, rule.bindings);
         const result = await tx.executeSql(rule.sql, values);
         const v = result.rows[0].result;
         if (v === false || v === 0 || v === '0') {
-            throw new SbvrValidationError(rule.structuredEnglish);
+            throw new errors_1.SbvrValidationError(rule.structuredEnglish);
         }
     }));
 };
-export const generateLfModel = (seModel) => cachedCompile('lfModel', ExtendedSBVRParser.version, seModel, () => ExtendedSBVRParser.matchAll(seModel, 'Process'));
-export const generateAbstractSqlModel = (lfModel) => cachedCompile('abstractSqlModel', LF2AbstractSQLTranslatorVersion, lfModel, () => LF2AbstractSQLTranslator(lfModel, 'Process'));
-export const generateSqlModel = (abstractSql, targetDatabaseEngine) => cachedCompile('sqlModel', AbstractSQLCompilerVersion + '+' + targetDatabaseEngine, abstractSql, () => AbstractSQLCompiler[targetDatabaseEngine].compileSchema(abstractSql));
-export function generateModels(model, targetDatabaseEngine) {
+exports.validateModel = validateModel;
+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) => (0, cached_compile_1.cachedCompile)('abstractSqlModel', LF2AbstractSQLTranslatorVersion, lfModel, () => LF2AbstractSQLTranslator(lfModel, 'Process'));
+exports.generateAbstractSqlModel = generateAbstractSqlModel;
+const generateSqlModel = (abstractSql, targetDatabaseEngine) => (0, cached_compile_1.cachedCompile)('sqlModel', package_json_1.version + '+' + targetDatabaseEngine, abstractSql, () => AbstractSQLCompiler[targetDatabaseEngine].compileSchema(abstractSql));
+exports.generateSqlModel = generateSqlModel;
+function generateModels(model, targetDatabaseEngine) {
     const { apiRoot: vocab, modelText: se, translateTo, translations } = model;
     let { abstractSql: maybeAbstractSql } = model;
     let lf;
     if (se) {
         try {
-            lf = 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 = generateAbstractSqlModel(lf);
+            maybeAbstractSql = (0, exports.generateAbstractSqlModel)(lf);
         }
         catch (e) {
             console.error(`Error translating model '${vocab}':`, e);
@@ -253,18 +299,18 @@ export function generateModels(model, targetDatabaseEngine) {
         }
     }
     const abstractSql = maybeAbstractSql;
-    const odataMetadata = cachedCompile('metadata', generateODataMetadata.version, { vocab, abstractSqlModel: abstractSql }, () => 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;
     let resourceRenames;
     if (translateTo != null) {
-        resourceRenames = translateAbstractSqlModel(abstractSql, models[translateTo].abstractSql, model.apiRoot, translateTo, translations);
+        resourceRenames = (0, translations_1.translateAbstractSqlModel)(abstractSql, models[translateTo].abstractSql, model.apiRoot, translateTo, translations);
     }
     else {
         for (const [key, table] of Object.entries(abstractSql.tables)) {
             abstractSql.tables[`${key}$${model.apiRoot}`] = { ...table };
         }
         try {
-            sql = generateSqlModel(abstractSql, targetDatabaseEngine);
+            sql = (0, exports.generateSqlModel)(abstractSql, targetDatabaseEngine);
         }
         catch (e) {
             console.error(`Error compiling model '${vocab}':`, e);
@@ -282,17 +328,18 @@ export function generateModels(model, targetDatabaseEngine) {
         odataMetadata,
     };
 }
-export const executeModel = (tx, model) => executeModels(tx, [model]);
-export const executeModels = async (tx, execModels) => {
+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) => {
             const { apiRoot } = model;
             const migrationExecutionResult = await syncMigrator.run(tx, model);
-            const compiledModel = generateModels(model, db.engine);
+            const compiledModel = generateModels(model, exports.db.engine);
             if (compiledModel.sql) {
                 for (const createStatement of compiledModel.sql.createSchema) {
                     const promise = tx.executeSql(createStatement);
-                    if (db.engine === 'websql') {
+                    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);
                         });
@@ -315,19 +362,19 @@ export const executeModels = async (tx, execModels) => {
                 },
             };
             if (compiledModel.sql) {
-                await validateModel(tx, apiRoot);
+                await (0, exports.validateModel)(tx, apiRoot);
             }
-            api[apiRoot] = new PinejsClient('/' + apiRoot + '/');
-            logger[apiRoot] = { ...console };
+            exports.api[apiRoot] = new PinejsClient('/' + apiRoot + '/');
+            exports.logger[apiRoot] = { ...console };
             if (model.logging != null) {
                 const defaultSetting = model.logging?.default ?? true;
-                const log = logger[apiRoot];
+                const log = exports.logger[apiRoot];
                 for (const k of Object.keys(model.logging)) {
                     const key = k;
                     if (key !== 'Console' &&
                         typeof log[key] === 'function' &&
                         !(model.logging?.[key] ?? defaultSetting)) {
-                        log[key] = _.noop;
+                        log[key] = lodash_1.default.noop;
                     }
                 }
             }
@@ -336,7 +383,7 @@ export const executeModels = async (tx, execModels) => {
         await Promise.all(compiledModels.map(async (model) => {
             const updateModel = async (modelType) => {
                 if (model[modelType] == null) {
-                    await api.dev.delete({
+                    await exports.api.dev.delete({
                         resource: 'model',
                         passthrough: {
                             tx,
@@ -351,7 +398,7 @@ export const executeModels = async (tx, execModels) => {
                     });
                     return;
                 }
-                const result = await api.dev.get({
+                const result = await exports.api.dev.get({
                     resource: 'model',
                     passthrough: {
                         tx,
@@ -383,7 +430,7 @@ export const executeModels = async (tx, execModels) => {
                 else {
                     uri += '?returnResource=false';
                 }
-                return await 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));
         }));
@@ -398,26 +445,28 @@ export const executeModels = async (tx, execModels) => {
         throw err;
     }
 };
-export const postExecuteModels = async (tx) => {
+exports.executeModels = executeModels;
+const postExecuteModels = async (tx) => {
     for (const modelKey of Object.keys(models)) {
         const pendingToSetExecutedMigrations = models[modelKey]?.modelExecutionResult?.migrationExecutionResult
             ?.pendingUnsetMigrations;
         if (pendingToSetExecutedMigrations != null) {
-            await setExecutedMigrations(tx, modelKey, pendingToSetExecutedMigrations);
+            await (0, utils_1.setExecutedMigrations)(tx, modelKey, pendingToSetExecutedMigrations);
         }
     }
 };
+exports.postExecuteModels = postExecuteModels;
 const cleanupModel = (vocab) => {
     delete models[vocab];
-    delete api[vocab];
+    delete exports.api[vocab];
 };
-export const deleteModel = async (vocabulary) => {
+const deleteModel = async (vocabulary) => {
     const { sql } = models[vocabulary];
     if (sql) {
-        await db.transaction(async (tx) => {
+        await exports.db.transaction(async (tx) => {
             const dropStatements = sql.dropSchema.map((dropStatement) => tx.executeSql(dropStatement));
             await Promise.all(dropStatements.concat([
-                api.dev.delete({
+                exports.api.dev.delete({
                     resource: 'model',
                     passthrough: {
                         tx,
@@ -434,9 +483,10 @@ export const deleteModel = async (vocabulary) => {
     }
     cleanupModel(vocabulary);
 };
+exports.deleteModel = deleteModel;
 const isWhereNode = (x) => x[0] === 'Where';
 const isEqualsNode = (x) => x[0] === 'Equals';
-export const getID = (vocab, request) => {
+const getID = (vocab, request) => {
     if (request.abstractSqlQuery == null) {
         throw new Error('Can only get the id if an abstractSqlQuery is provided');
     }
@@ -457,22 +507,23 @@ export const getID = (vocab, request) => {
     }
     return 0;
 };
-export const runRule = (() => {
+exports.getID = getID;
+exports.runRule = (() => {
     const LF2AbstractSQLPrepHack = LF2AbstractSQL.LF2AbstractSQLPrep._extend({
         CardinalityOptimisation() {
             this._pred(false);
         },
     });
     const translator = LF2AbstractSQL.LF2AbstractSQL.createInstance();
-    translator.addTypes(sbvrTypes);
+    translator.addTypes(sbvr_types_1.default);
     return async (vocab, rule) => {
         const seModel = models[vocab].se;
-        const log = logger[vocab];
+        const log = exports.logger[vocab];
         let lfModel;
         let slfModel;
         let abstractSqlModel;
         try {
-            lfModel = ExtendedSBVRParser.matchAll(seModel + '\nRule: ' + rule, 'Process');
+            lfModel = extended_sbvr_parser_1.ExtendedSBVRParser.matchAll(seModel + '\nRule: ' + rule, 'Process');
         }
         catch (e) {
             log.error('Error parsing rule', rule, e);
@@ -499,7 +550,7 @@ export const runRule = (() => {
             resourceName = ruleLF[1][1][1][2][1];
         }
         let fetchingViolators = false;
-        const ruleAbs = _.last(abstractSqlModel.rules);
+        const ruleAbs = lodash_1.default.last(abstractSqlModel.rules);
         if (ruleAbs == null) {
             throw new Error('Unable to generate rule');
         }
@@ -536,21 +587,21 @@ export const runRule = (() => {
             }
             return ['Select', '*'];
         });
-        const compiledRule = AbstractSQLCompiler[db.engine].compileRule(ruleBody);
+        const compiledRule = AbstractSQLCompiler[exports.db.engine].compileRule(ruleBody);
         if (Array.isArray(compiledRule)) {
             throw new Error('Unexpected query generated');
         }
-        const values = await getAndCheckBindValues({
+        const values = await (0, abstract_sql_1.getAndCheckBindValues)({
             vocabulary: vocab,
             odataBinds: [],
             values: {},
-            engine: db.engine,
+            engine: exports.db.engine,
         }, compiledRule.bindings);
-        const result = await db.executeSql(compiledRule.query, values);
+        const result = await exports.db.executeSql(compiledRule.query, values);
         const table = models[vocab].abstractSql.tables[resourceName];
-        const odataIdField = 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 = lodash_1.default.uniq(ids);
         ids = ids.map((id) => odataIdField + ' eq ' + id);
         let filter;
         if (ids.length > 0) {
@@ -559,10 +610,10 @@ export const runRule = (() => {
         else {
             filter = '0 eq 1';
         }
-        const odataResult = (await runURI('GET', '/' +
+        const odataResult = (await (0, exports.runURI)('GET', '/' +
             vocab +
             '/' +
-            sqlNameToODataName(table.resourceName) +
+            (0, odata_to_abstract_sql_1.sqlNameToODataName)(table.resourceName) +
             '?$filter=' +
             filter, undefined, undefined, permissions.rootRead));
         odataResult.__formulationType = formulationType;
@@ -570,9 +621,9 @@ export const runRule = (() => {
         return odataResult;
     };
 })();
-export class PinejsClient extends PinejsClientCore {
+class PinejsClient extends pinejs_client_core_1.PinejsClientCore {
     async _request({ method, url, body, tx, req, custom, }) {
-        return (await runURI(method, url, body, tx, req, custom));
+        return (await (0, exports.runURI)(method, url, body, tx, req, custom));
     }
     post(params) {
         return super.post(params);
@@ -606,12 +657,13 @@ export class PinejsClient extends PinejsClientCore {
         return `${authBase}?${compiledFilter}`;
     }
 }
-export const api = {};
-export const logger = {};
-export const runURI = async (method, uri, body = {}, tx, req, custom) => {
+exports.PinejsClient = PinejsClient;
+exports.api = {};
+exports.logger = {};
+const runURI = async (method, uri, body = {}, tx, req, custom) => {
     const [, apiRoot] = uri.split('/', 2);
     if (apiRoot == null || models[apiRoot] == null) {
-        throw new InternalRequestError();
+        throw new errors_1.InternalRequestError();
     }
     let user;
     let apiKey;
@@ -629,13 +681,13 @@ export const runURI = async (method, uri, body = {}, tx, req, custom) => {
             permissions: [],
         };
     }
-    _.forEach(body, (v, k) => {
+    lodash_1.default.forEach(body, (v, k) => {
         if (v === undefined) {
             delete body[k];
         }
     });
     const emulatedReq = {
-        on: _.noop,
+        on: lodash_1.default.noop,
         custom,
         user,
         apiKey,
@@ -648,28 +700,30 @@ export const runURI = async (method, uri, body = {}, tx, req, custom) => {
     };
     const { promise } = runODataRequest(emulatedReq, apiRoot);
     const [response] = await promise;
-    if (_.isError(response)) {
+    if (lodash_1.default.isError(response)) {
         throw response;
     }
     const { body: responseBody, statusCode, headers } = response;
     if (statusCode != null && statusCode >= 400) {
-        const ErrorClass = statusCodeToError[statusCode];
+        const ErrorClass = errors_1.statusCodeToError[statusCode];
         if (ErrorClass != null) {
             throw new ErrorClass(undefined, responseBody, headers);
         }
-        throw new HttpError(statusCode, undefined, responseBody, headers);
+        throw new errors_1.HttpError(statusCode, undefined, responseBody, headers);
     }
     return responseBody;
 };
-export const getAbstractSqlModel = (request) => {
+exports.runURI = runURI;
+const getAbstractSqlModel = (request) => {
     return (request.abstractSqlModel ??= models[request.vocabulary].abstractSql);
 };
+exports.getAbstractSqlModel = getAbstractSqlModel;
 const getFinalAbstractSqlModel = (request) => {
-    const finalModel = _.last(request.translateVersions);
+    const finalModel = lodash_1.default.last(request.translateVersions);
     return (request.finalAbstractSqlModel ??= models[finalModel].abstractSql);
 };
-const getIdField = (request) => getFinalAbstractSqlModel(request).tables[resolveSynonym(request)].idField;
-export const getAffectedIds = async (args) => {
+const getIdField = (request) => getFinalAbstractSqlModel(request).tables[(0, exports.resolveSynonym)(request)].idField;
+const getAffectedIds = async (args) => {
     const { request } = args;
     if (request.affectedIds) {
         return request.affectedIds;
@@ -682,6 +736,7 @@ export const getAffectedIds = async (args) => {
     delete request.pendingAffectedIds;
     return request.affectedIds;
 };
+exports.getAffectedIds = getAffectedIds;
 const $getAffectedIds = async ({ req, request, tx, }) => {
     if (!['PATCH', 'DELETE'].includes(request.method)) {
         throw new Error('Can only call `getAffectedIds` with PATCH/DELETE requests');
@@ -693,8 +748,8 @@ const $getAffectedIds = async ({ req, request, tx, }) => {
     parsedRequest.engine = request.engine;
     parsedRequest.translateVersions = request.translateVersions;
     let affectedRequest = parsedRequest;
-    const abstractSqlModel = getAbstractSqlModel(affectedRequest);
-    const resourceName = resolveSynonym(affectedRequest);
+    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: ' + affectedRequest.resourceName);
@@ -708,7 +763,7 @@ const $getAffectedIds = async ({ req, request, tx, }) => {
     await permissions.addPermissions(req, affectedRequest);
     affectedRequest.method = 'GET';
     affectedRequest = uriParser.translateUri(affectedRequest);
-    affectedRequest = compileRequest(affectedRequest);
+    affectedRequest = (0, abstract_sql_1.compileRequest)(affectedRequest);
     let result;
     if (tx != null) {
         result = await runQuery(tx, affectedRequest);
@@ -718,17 +773,18 @@ const $getAffectedIds = async ({ req, request, tx, }) => {
     }
     return result.rows.map((row) => row[idField]);
 };
-export const getModel = (vocabulary) => {
+const getModel = (vocabulary) => {
     return models[vocabulary];
 };
+exports.getModel = getModel;
 const runODataRequest = (req, vocabulary) => {
-    if (env.DEBUG) {
-        logger[vocabulary].log('Parsing', req.method, req.url);
+    if (module_1.env.DEBUG) {
+        exports.logger[vocabulary].log('Parsing', req.method, req.url);
     }
     const { versions } = models[vocabulary];
     const reqHooks = versions.map((version) => [
         version,
-        getHooks({
+        (0, hooks_1.getHooks)({
             method: req.method,
             vocabulary: version,
         }, version === versions[0]),
@@ -746,7 +802,7 @@ const runODataRequest = (req, vocabulary) => {
             }
         });
         transactions.length = 0;
-        rollbackRequestHooks(reqHooks);
+        (0, hooks_1.rollbackRequestHooks)(reqHooks);
     };
     req.on('close', tryCancelRequest);
     if (req.tx != null) {
@@ -757,7 +813,7 @@ const runODataRequest = (req, vocabulary) => {
     return {
         tryCancelRequest,
         promise: (async () => {
-            await 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;
@@ -767,51 +823,51 @@ const runODataRequest = (req, vocabulary) => {
                 requests = [{ method, url, data: body }];
             }
             const prepareRequest = async (parsedRequest) => {
-                const abstractSqlModel = getAbstractSqlModel(parsedRequest);
+                const abstractSqlModel = (0, exports.getAbstractSqlModel)(parsedRequest);
                 if (abstractSqlModel == null) {
-                    throw new BadRequestError('Unknown vocabulary: ' + parsedRequest.vocabulary);
+                    throw new errors_1.BadRequestError('Unknown vocabulary: ' + parsedRequest.vocabulary);
                 }
-                parsedRequest.engine = db.engine;
+                parsedRequest.engine = exports.db.engine;
                 parsedRequest.translateVersions = [...versions];
                 const $request = parsedRequest;
                 try {
-                    let resolvedResourceName = resolveSynonym($request);
+                    let resolvedResourceName = (0, exports.resolveSynonym)($request);
                     if (resolvedResourceName.endsWith('#canAccess')) {
                         resolvedResourceName = resolvedResourceName.slice(0, -'#canAccess'.length);
                     }
                     if (abstractSqlModel.tables[resolvedResourceName] == null) {
-                        throw new UnauthorizedError();
+                        throw new errors_1.UnauthorizedError();
                     }
                     $request.hooks = [];
                     for (const version of versions) {
                         const hooks = [
                             version,
-                            getHooks({
+                            (0, hooks_1.getHooks)({
                                 resourceName: $request.resourceName,
                                 vocabulary: version,
                                 method: $request.method,
                             }, version === versions[0]),
                         ];
                         $request.hooks.push(hooks);
-                        await runHooks('POSTPARSE', [hooks], {
+                        await (0, hooks_1.runHooks)('POSTPARSE', [hooks], {
                             req,
                             request: $request,
                             tx: req.tx,
                         });
                         const { resourceRenames } = models[version];
                         if (resourceRenames) {
-                            const resourceName = resolveSynonym($request);
+                            const resourceName = (0, exports.resolveSynonym)($request);
                             if (resourceRenames[resourceName]) {
-                                $request.resourceName = sqlNameToODataName(resourceRenames[resourceName]);
+                                $request.resourceName = (0, odata_to_abstract_sql_1.sqlNameToODataName)(resourceRenames[resourceName]);
                             }
                         }
                     }
                     const translatedRequest = uriParser.translateUri($request);
-                    return compileRequest(translatedRequest);
+                    return (0, abstract_sql_1.compileRequest)(translatedRequest);
                 }
                 catch (err) {
-                    rollbackRequestHooks(reqHooks);
-                    rollbackRequestHooks($request.hooks);
+                    (0, hooks_1.rollbackRequestHooks)(reqHooks);
+                    (0, hooks_1.rollbackRequestHooks)($request.hooks);
                     throw err;
                 }
             };
@@ -827,14 +883,14 @@ const runODataRequest = (req, vocabulary) => {
                 return await runTransaction(req, request, async (tx) => {
                     transactions.push(tx);
                     tx.on('rollback', () => {
-                        rollbackRequestHooks(reqHooks);
+                        (0, hooks_1.rollbackRequestHooks)(reqHooks);
                         if (Array.isArray(request)) {
                             for (const { hooks } of request) {
-                                rollbackRequestHooks(hooks);
+                                (0, hooks_1.rollbackRequestHooks)(hooks);
                             }
                         }
                         else {
-                            rollbackRequestHooks(request.hooks);
+                            (0, hooks_1.rollbackRequestHooks)(request.hooks);
                         }
                     });
                     if (Array.isArray(request)) {
@@ -851,7 +907,7 @@ const runODataRequest = (req, vocabulary) => {
                 });
             });
             const responses = results.map((result) => {
-                if (_.isError(result)) {
+                if (lodash_1.default.isError(result)) {
                     return convertToHttpError(result);
                 }
                 else {
@@ -859,7 +915,7 @@ const runODataRequest = (req, vocabulary) => {
                         result.body == null &&
                         result.statusCode == null) {
                         console.error('No status or body set', req.url, responses);
-                        return new InternalRequestError();
+                        return new errors_1.InternalRequestError();
                     }
                     return result;
                 }
@@ -868,12 +924,13 @@ const runODataRequest = (req, vocabulary) => {
         })(),
     };
 };
-export const getApiRoot = (req) => {
+const getApiRoot = (req) => {
     const [, apiRoot] = req.url.split('/', 2);
     return apiRoot;
 };
-export const handleODataRequest = async (req, res, next) => {
-    const apiRoot = getApiRoot(req);
+exports.getApiRoot = getApiRoot;
+const handleODataRequest = async (req, res, next) => {
+    const apiRoot = (0, exports.getApiRoot)(req);
     if (apiRoot == null || models[apiRoot] == null) {
         next('route');
         return;
@@ -885,14 +942,14 @@ export const handleODataRequest = async (req, res, next) => {
         res.set('Cache-Control', 'no-cache');
         if (req.batch == null || req.batch.length === 0) {
             let [response] = responses;
-            if (response instanceof HttpError) {
+            if (response instanceof errors_1.HttpError) {
                 response = httpErrorToResponse(response);
             }
             handleResponse(res, response);
         }
         else {
             res.status(200).sendMulti(responses.map((response) => {
-                if (response instanceof HttpError) {
+                if (response instanceof errors_1.HttpError) {
                     return httpErrorToResponse(response);
                 }
                 else {
@@ -902,19 +959,21 @@ export const handleODataRequest = async (req, res, next) => {
         }
     }
     catch (e) {
-        if (handleHttpErrors(req, res, e)) {
+        if ((0, exports.handleHttpErrors)(req, res, e)) {
             return;
         }
         console.error('An error occurred while constructing the response', e);
         res.status(500).end();
     }
 };
+exports.handleODataRequest = handleODataRequest;
 const handleErrorFns = [];
-export const onHandleHttpError = (fn) => {
+const onHandleHttpError = (fn) => {
     handleErrorFns.push(fn);
 };
-export const handleHttpErrors = (req, res, err) => {
-    if (err instanceof HttpError) {
+exports.onHandleHttpError = onHandleHttpError;
+const handleHttpErrors = (req, res, err) => {
+    if (err instanceof errors_1.HttpError) {
         for (const handleErrorFn of handleErrorFns) {
             handleErrorFn(req, err);
         }
@@ -924,6 +983,7 @@ export const handleHttpErrors = (req, res, err) => {
     }
     return false;
 };
+exports.handleHttpErrors = handleHttpErrors;
 const handleResponse = (res, response) => {
     const { body, headers, statusCode } = response;
     res.set(headers);
@@ -943,38 +1003,38 @@ const httpErrorToResponse = (err) => {
     };
 };
 const convertToHttpError = (err) => {
-    if (err instanceof HttpError) {
+    if (err instanceof errors_1.HttpError) {
         return err;
     }
-    if (err instanceof SbvrValidationError) {
-        return new BadRequestError(err);
+    if (err instanceof errors_1.SbvrValidationError) {
+        return new errors_1.BadRequestError(err);
     }
-    if (err instanceof PermissionError) {
-        return new UnauthorizedError(err);
+    if (err instanceof errors_1.PermissionError) {
+        return new errors_1.UnauthorizedError(err);
     }
-    if (err instanceof db.ConstraintError) {
-        return new ConflictError(err);
+    if (err instanceof exports.db.ConstraintError) {
+        return new errors_1.ConflictError(err);
     }
-    if (err instanceof SqlCompilationError ||
-        err instanceof TranslationError ||
-        err instanceof ParsingError ||
-        err instanceof PermissionParsingError ||
-        err instanceof db.DatabaseError) {
-        return new InternalRequestError();
+    if (err instanceof errors_1.SqlCompilationError ||
+        err instanceof errors_1.TranslationError ||
+        err instanceof errors_1.ParsingError ||
+        err instanceof errors_1.PermissionParsingError ||
+        err instanceof exports.db.DatabaseError) {
+        return new errors_1.InternalRequestError();
     }
     console.error('Unexpected response error type', err);
-    return new InternalRequestError();
+    return new errors_1.InternalRequestError();
 };
 const runRequest = async (req, tx, request) => {
-    const log = logger[request.vocabulary];
-    if (env.DEBUG) {
+    const log = exports.logger[request.vocabulary];
+    if (module_1.env.DEBUG) {
         log.log('Running', req.method, req.url);
     }
     let resultGet;
     let resultPost;
     try {
         try {
-            await runHooks('PRERUN', request.hooks, { req, request, tx });
+            await (0, hooks_1.runHooks)('PRERUN', request.hooks, { req, request, tx });
             switch (request.method) {
                 case 'GET':
                     resultGet = await runGet(req, request, tx);
@@ -993,7 +1053,7 @@ const runRequest = async (req, tx, request) => {
             }
         }
         catch (err) {
-            if (err instanceof db.DatabaseError) {
+            if (err instanceof exports.db.DatabaseError) {
                 prettifyConstraintError(err, request);
                 log.error(err);
                 err.message = 'Database error';
@@ -1007,11 +1067,11 @@ const runRequest = async (req, tx, request) => {
                 err instanceof TypeError ||
                 err instanceof URIError) {
                 log.error(err);
-                throw new InternalRequestError();
+                throw new errors_1.InternalRequestError();
             }
             throw err;
         }
-        await runHooks('POSTRUN', request.hooks, {
+        await (0, hooks_1.runHooks)('POSTRUN', request.hooks, {
             req,
             request,
             result: resultGet ?? resultPost,
@@ -1019,7 +1079,7 @@ const runRequest = async (req, tx, request) => {
         });
     }
     catch (err) {
-        await runHooks('POSTRUN-ERROR', request.hooks, {
+        await (0, hooks_1.runHooks)('POSTRUN-ERROR', request.hooks, {
             req,
             request,
             tx,
@@ -1041,7 +1101,7 @@ const runRequest = async (req, tx, request) => {
         case 'OPTIONS':
             return await respondOptions(req, request, tx);
         default:
-            throw new MethodNotAllowedError();
+            throw new errors_1.MethodNotAllowedError();
     }
 };
 const runChangeSet = (req, tx) => async (changeSetResults, request) => {
@@ -1063,7 +1123,7 @@ const updateBinds = (changeSetResults, request) => {
                 if (ref?.body == null ||
                     typeof ref.body === 'string' ||
                     ref.body.id === undefined) {
-                    throw new BadRequestError('Reference to a non existing resource in Changeset');
+                    throw new errors_1.BadRequestError('Reference to a non existing resource in Changeset');
                 }
                 request.odataBinds[i] = uriParser.parseId(ref.body.id);
             }
@@ -1089,33 +1149,33 @@ const runTransaction = async (req, request, callback) => {
     }
     if (Array.isArray(request)) {
         if (request.every(checkReadOnlyRequests)) {
-            return await db.readTransaction(callback);
+            return await exports.db.readTransaction(callback);
         }
     }
     else if (checkReadOnlyRequests(request)) {
-        return await db.readTransaction(callback);
+        return await exports.db.readTransaction(callback);
     }
-    return await db.transaction(callback);
+    return await exports.db.transaction(callback);
 };
 const runQuery = async (tx, request, queryIndex, addReturning = false) => {
     const { vocabulary } = request;
     let { sqlQuery } = request;
     if (sqlQuery == null) {
-        throw new InternalRequestError('No SQL query available to run');
+        throw new errors_1.InternalRequestError('No SQL query available to run');
     }
     if (request.engine == null) {
-        throw new InternalRequestError('No database engine specified');
+        throw new errors_1.InternalRequestError('No database engine specified');
     }
     if (Array.isArray(sqlQuery)) {
         if (queryIndex == null) {
-            throw new InternalRequestError('Received a query index to run but the query is not an array');
+            throw new errors_1.InternalRequestError('Received a query index to run but the query is not an array');
         }
         sqlQuery = sqlQuery[queryIndex];
     }
     const { query, bindings } = sqlQuery;
-    const values = await getAndCheckBindValues(request, bindings);
-    if (env.DEBUG) {
-        logger[vocabulary].log(query, values);
+    const values = await (0, abstract_sql_1.getAndCheckBindValues)(request, bindings);
+    if (module_1.env.DEBUG) {
+        exports.logger[vocabulary].log(query, values);
     }
     const returningIdField = addReturning && request.affectedIds == null ? getIdField(request) : false;
     const sqlResult = await tx.executeSql(query, values, returningIdField);
@@ -1139,13 +1199,13 @@ const respondGet = async (req, request, result, tx) => {
         const metadata = format != null && typeof format === 'object'
             ? format.metadata
             : undefined;
-        const d = await odataResponse.process(vocab, getAbstractSqlModel(request), request.originalResourceName, result.rows, { includeMetadata: metadata === 'full' });
+        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 runHooks('PRERESPOND', request.hooks, {
+        await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
             req,
             request,
             result,
@@ -1172,22 +1232,22 @@ const respondGet = async (req, request, result, tx) => {
 const runPost = async (_req, request, tx) => {
     const { rowsAffected, insertId } = await runQuery(tx, request, undefined, true);
     if (rowsAffected === 0) {
-        throw new PermissionError();
+        throw new errors_1.PermissionError();
     }
-    await validateModel(tx, _.last(request.translateVersions), request);
+    await (0, exports.validateModel)(tx, lodash_1.default.last(request.translateVersions), request);
     return insertId;
 };
 const respondPost = async (req, request, id, tx) => {
     const vocab = request.vocabulary;
     const location = odataResponse.resourceURI(vocab, request.originalResourceName, id);
-    if (env.DEBUG) {
-        logger[vocab].log('Insert ID: ', request.resourceName, id);
+    if (module_1.env.DEBUG) {
+        exports.logger[vocab].log('Insert ID: ', request.resourceName, id);
     }
     let result = { d: [{ id }] };
     if (location != null &&
         !['0', 'false'].includes(request?.odataQuery?.options?.returnResource)) {
         try {
-            result = (await runURI('GET', location, undefined, tx, req));
+            result = (await (0, exports.runURI)('GET', location, undefined, tx, req));
         }
         catch {
         }
@@ -1200,7 +1260,7 @@ const respondPost = async (req, request, id, tx) => {
             location,
         },
     };
-    await runHooks('PRERESPOND', request.hooks, {
+    await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
         req,
         request,
         result,
@@ -1221,14 +1281,14 @@ const runPut = async (_req, request, tx) => {
         ({ rowsAffected } = await runQuery(tx, request, undefined, true));
     }
     if (rowsAffected > 0) {
-        await validateModel(tx, _.last(request.translateVersions), request);
+        await (0, exports.validateModel)(tx, lodash_1.default.last(request.translateVersions), request);
     }
 };
 const respondPut = async (req, request, tx) => {
     const response = {
         statusCode: 200,
     };
-    await runHooks('PRERESPOND', request.hooks, {
+    await (0, hooks_1.runHooks)('PRERESPOND', request.hooks, {
         req,
         request,
         response,
@@ -1241,7 +1301,7 @@ const respondOptions = respondPut;
 const runDelete = async (_req, request, tx) => {
     const { rowsAffected } = await runQuery(tx, request, undefined, true);
     if (rowsAffected > 0) {
-        await validateModel(tx, _.last(request.translateVersions), request);
+        await (0, exports.validateModel)(tx, lodash_1.default.last(request.translateVersions), request);
     }
 };
 const devModelConfig = {
@@ -1281,10 +1341,10 @@ const devModelConfig = {
         },
     },
 };
-export const executeStandardModels = async (tx) => {
+const executeStandardModels = async (tx) => {
     try {
-        await executeModel(tx, devModelConfig);
-        await executeModels(tx, permissions.config.models);
+        await (0, exports.executeModel)(tx, devModelConfig);
+        await (0, exports.executeModels)(tx, permissions.config.models);
         console.info('Successfully executed standard models.');
     }
     catch (err) {
@@ -1292,11 +1352,12 @@ export const executeStandardModels = async (tx) => {
         throw err;
     }
 };
-export const setup = async (_app, $db) => {
-    db = $db;
+exports.executeStandardModels = executeStandardModels;
+const setup = async (_app, $db) => {
+    exports.db = $db;
     try {
-        await db.transaction(async (tx) => {
-            await executeStandardModels(tx);
+        await exports.db.transaction(async (tx) => {
+            await (0, exports.executeStandardModels)(tx);
             permissions.setup();
         });
     }
@@ -1305,16 +1366,17 @@ export const setup = async (_app, $db) => {
         process.exit(1);
     }
     try {
-        await db.executeSql('CREATE UNIQUE INDEX "uniq_model_model_type_vocab" ON "model" ("is of-vocabulary", "model type");');
+        await exports.db.executeSql('CREATE UNIQUE INDEX "uniq_model_model_type_vocab" ON "model" ("is of-vocabulary", "model type");');
     }
     catch {
     }
 };
-export const postSetup = async (_app, $db) => {
-    db = $db;
+exports.setup = setup;
+const postSetup = async (_app, $db) => {
+    exports.db = $db;
     try {
-        await db.transaction(async (tx) => {
-            await postExecuteModels(tx);
+        await exports.db.transaction(async (tx) => {
+            await (0, exports.postExecuteModels)(tx);
         });
     }
     catch (err) {
@@ -1322,4 +1384,5 @@ export const postSetup = async (_app, $db) => {
         process.exit(1);
     }
 };
+exports.postSetup = postSetup;
 //# sourceMappingURL=sbvr-utils.js.map