velocious 1.0.108 → 1.0.109

package/dist/src/environment-handlers/node/cli/commands/generate/migration.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @typedef {{date: Date, migrationContent: string, migrationName: string, migrationNameCamelized: string, migrationNumber: string, migrationPath: string}} DbGenerateMigrationReturnType
+ */
+export default class DbGenerateMigration extends BaseCommand {
+    /**
+     * @returns {Promise<void | DbGenerateMigrationReturnType>}
+     */
+    execute(): Promise<void | DbGenerateMigrationReturnType>;
+}
+export type DbGenerateMigrationReturnType = {
+    date: Date;
+    migrationContent: string;
+    migrationName: string;
+    migrationNameCamelized: string;
+    migrationNumber: string;
+    migrationPath: string;
+};
+import BaseCommand from "../../../../../cli/base-command.js";
+//# sourceMappingURL=migration.d.ts.map

package/dist/src/environment-handlers/node/cli/commands/generate/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/migration.js"],"names":[],"mappings":"AAMA;;GAEG;AAEH;IACE;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG,6BAA6B,CAAC,CA0BzD;CACF;4CAhCY;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,sBAAsB,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC;wBAPlI,oCAAoC"}

package/dist/src/environment-handlers/node/cli/commands/generate/migration.js

@@ -0,0 +1,36 @@
+import BaseCommand from "../../../../../cli/base-command.js";
+import fileExists from "../../../../../utils/file-exists.js";
+import fs from "fs/promises";
+import * as inflection from "inflection";
+import strftime from "strftime";
+/**
+ * @typedef {{date: Date, migrationContent: string, migrationName: string, migrationNameCamelized: string, migrationNumber: string, migrationPath: string}} DbGenerateMigrationReturnType
+ */
+export default class DbGenerateMigration extends BaseCommand {
+    /**
+     * @returns {Promise<void | DbGenerateMigrationReturnType>}
+     */
+    async execute() {
+        const migrationName = this.processArgs[1];
+        const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"));
+        const date = new Date();
+        const migrationNumber = strftime("%Y%m%d%H%M%S");
+        const migrationFileName = `${migrationNumber}-${migrationName}.js`;
+        const velociousPath = await this.getEnvironmentHandler().getVelociousPath();
+        const templateFilePath = `${velociousPath}/src/templates/generate-migration.js`;
+        const migrationContentBuffer = await fs.readFile(templateFilePath);
+        const migrationContent = migrationContentBuffer.toString().replaceAll("__MIGRATION_NAME__", migrationNameCamelized);
+        const migrationDir = `${process.cwd()}/src/database/migrations`;
+        const migrationPath = `${migrationDir}/${migrationFileName}`;
+        if (this.args.testing) {
+            return { date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath };
+        }
+        else {
+            if (!await fileExists(migrationDir)) {
+                await fs.mkdir(migrationDir, { recursive: true });
+            }
+            await fs.writeFile(migrationPath, migrationContent);
+            console.log(`create src/database/migrations/${migrationFileName}`);
+        }
+    }
+}

package/dist/src/environment-handlers/node/cli/commands/generate/model.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @typedef {{date: Date, modelContent: string, modelName: string, modelNameCamelized: string, modelPath: string}} DbGenerateModelResult
+ */
+export default class DbGenerateModel extends BaseCommand {
+    /**
+     * @returns {Promise<void | DbGenerateModelResult>}
+     */
+    execute(): Promise<void | DbGenerateModelResult>;
+}
+export type DbGenerateModelResult = {
+    date: Date;
+    modelContent: string;
+    modelName: string;
+    modelNameCamelized: string;
+    modelPath: string;
+};
+import BaseCommand from "../../../../../cli/base-command.js";
+//# sourceMappingURL=model.d.ts.map

package/dist/src/environment-handlers/node/cli/commands/generate/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/model.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;IACE;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG,qBAAqB,CAAC,CA2BjD;CACF;oCAjCY;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;wBANzF,oCAAoC"}

package/dist/src/environment-handlers/node/cli/commands/generate/model.js

@@ -0,0 +1,36 @@
+import BaseCommand from "../../../../../cli/base-command.js";
+import fileExists from "../../../../../utils/file-exists.js";
+import fs from "fs/promises";
+import * as inflection from "inflection";
+/**
+ * @typedef {{date: Date, modelContent: string, modelName: string, modelNameCamelized: string, modelPath: string}} DbGenerateModelResult
+ */
+export default class DbGenerateModel extends BaseCommand {
+    /**
+     * @returns {Promise<void | DbGenerateModelResult>}
+     */
+    async execute() {
+        const modelName = this.processArgs[1];
+        const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"));
+        const date = new Date();
+        const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`;
+        const velociousPath = await this.getEnvironmentHandler().getVelociousPath();
+        const templateFilePath = `${velociousPath}/src/templates/generate-model.js`;
+        const modelContentBuffer = await fs.readFile(templateFilePath);
+        const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized);
+        const modelsDir = `${process.cwd()}/src/models`;
+        const modelPath = `${modelsDir}/${modelFileName}`;
+        if (await fileExists(modelPath))
+            throw new Error(`Model file already exists: ${modelPath}`);
+        if (this.args.testing) {
+            return { date, modelContent, modelName, modelNameCamelized, modelPath };
+        }
+        else {
+            if (!await fileExists(modelsDir)) {
+                await fs.mkdir(modelsDir, { recursive: true });
+            }
+            await fs.writeFile(modelPath, modelContent);
+            console.log(`create src/models/${modelFileName}`);
+        }
+    }
+}

package/dist/src/environment-handlers/node/cli/commands/init.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @typedef {{source: string, target: string}} FileMappingType
+ */
+export default class VelociousCliCommandsInit extends BaseCommand {
+    /**
+     * @returns {Promise<void | {fileMappings: FileMappingType[]}>}
+     */
+    execute(): Promise<void | {
+        fileMappings: FileMappingType[];
+    }>;
+}
+export type FileMappingType = {
+    source: string;
+    target: string;
+};
+import BaseCommand from "../../../../cli/base-command.js";
+export const dontLoadConfiguration: true;
+//# sourceMappingURL=init.d.ts.map

package/dist/src/environment-handlers/node/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../src/environment-handlers/node/cli/commands/init.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;IACE;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG;QAAC,YAAY,EAAE,eAAe,EAAE,CAAA;KAAC,CAAC,CAkD7D;CACF;8BAxDY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC;wBALrB,iCAAiC;AA+DzD,oCAA8B,IAAI,CAAA"}

package/dist/src/environment-handlers/node/cli/commands/init.js

@@ -0,0 +1,60 @@
+import BaseCommand from "../../../../cli/base-command.js";
+import fileExists from "../../../../utils/file-exists.js";
+import fs from "fs/promises";
+/**
+ * @typedef {{source: string, target: string}} FileMappingType
+ */
+export default class VelociousCliCommandsInit extends BaseCommand {
+    /**
+     * @returns {Promise<void | {fileMappings: FileMappingType[]}>}
+     */
+    async execute() {
+        const velociousPath = await this.getEnvironmentHandler().getVelociousPath();
+        const projectPath = this.getConfiguration()?.getDirectory() || process.cwd();
+        const projectConfigPath = `${projectPath}/src/config`;
+        const fileMappings = [
+            {
+                source: `${velociousPath}/src/templates/configuration.js`,
+                target: `${projectConfigPath}/configuration.js`
+            },
+            {
+                source: `${velociousPath}/src/templates/routes.js`,
+                target: `${projectConfigPath}/routes.js`
+            }
+        ];
+        const paths = [
+            projectConfigPath,
+            `${projectPath}/src/database/migrations`,
+            `${projectPath}/src/models`,
+            `${projectPath}/src/routes`
+        ];
+        if (this.args.testing) {
+            return {
+                fileMappings
+            };
+        }
+        for (const path of paths) {
+            if (await fileExists(path)) {
+                console.log(`Config dir already exists: ${path}`);
+            }
+            else {
+                console.log(`Config dir doesn't exists: ${path}`);
+                await fs.mkdir(path, { recursive: true });
+            }
+        }
+        for (const fileMapping of fileMappings) {
+            if (!await fileExists(fileMapping.source)) {
+                throw new Error(`Template doesn't exist: ${fileMapping.source}`);
+            }
+            if (await fileExists(fileMapping.target)) {
+                console.log(`File already exists: ${fileMapping.target}`);
+            }
+            else {
+                console.log(`File doesnt exist: ${fileMapping.target}`);
+                await fs.copyFile(fileMapping.source, fileMapping.target);
+            }
+        }
+    }
+}
+const dontLoadConfiguration = true;
+export { dontLoadConfiguration };

package/dist/src/environment-handlers/node/cli/commands/server.d.ts

@@ -0,0 +1,11 @@
+export default class VelociousCliCommandsServer extends BaseCommand {
+    execute(): Promise<void>;
+    databasePool: import("../../../../database/pool/base.js").default;
+    newConfiguration: {
+        driver: typeof import("../../../../database/drivers/base.js").default;
+        type: string;
+    };
+    databaseConnection: import("../../../../database/drivers/base.js").default;
+}
+import BaseCommand from "../../../../cli/base-command.js";
+//# sourceMappingURL=server.d.ts.map

package/dist/src/environment-handlers/node/cli/commands/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../../src/environment-handlers/node/cli/commands/server.js"],"names":[],"mappings":"AAGA;IACE,yBAwBC;IAvBC,kEAA6D;IAC7D;;;MAA+E;IAC/E,2EAAyG;CAsB5G;wBA5BuB,iCAAiC"}

package/dist/src/environment-handlers/node/cli/commands/server.js

@@ -0,0 +1,26 @@
+import Application from "../../../../application.js";
+import BaseCommand from "../../../../cli/base-command.js";
+export default class VelociousCliCommandsServer extends BaseCommand {
+    async execute() {
+        this.databasePool = this.getConfiguration().getDatabasePool();
+        this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration());
+        this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration);
+        await this.databaseConnection.connect();
+        const { parsedProcessArgs } = this.args;
+        const host = parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1";
+        const port = parsedProcessArgs.p || parsedProcessArgs.port || 3006;
+        const application = new Application({
+            configuration: this.getConfiguration(),
+            httpServer: {
+                host,
+                port
+            },
+            type: "server"
+        });
+        const environment = this.getConfiguration().getEnvironment();
+        await application.initialize();
+        await application.startHttpServer();
+        console.log(`Started Velocious HTTP server on ${host}:${port} in ${environment} environment`);
+        await application.wait();
+    }
+}

package/dist/src/environment-handlers/node/cli/commands/test.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousCliCommandsTest extends BaseCommand {
+    execute(): Promise<void>;
+}
+import BaseCommand from "../../../../cli/base-command.js";
+//# sourceMappingURL=test.d.ts.map

package/dist/src/environment-handlers/node/cli/commands/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../../../../src/environment-handlers/node/cli/commands/test.js"],"names":[],"mappings":"AAMA;IACE,yBAsCC;CACF;wBA5CuB,iCAAiC"}

package/dist/src/environment-handlers/node/cli/commands/test.js

@@ -0,0 +1,41 @@
+// @ts-check
+import BaseCommand from "../../../../cli/base-command.js";
+import TestFilesFinder from "../../../../testing/test-files-finder.js";
+import TestRunner from "../../../../testing/test-runner.js";
+export default class VelociousCliCommandsTest extends BaseCommand {
+    async execute() {
+        this.getConfiguration().setEnvironment("test");
+        let directory;
+        const directories = [];
+        if (process.env.VELOCIOUS_TEST_DIR) {
+            directory = process.env.VELOCIOUS_TEST_DIR;
+            directories.push(process.env.VELOCIOUS_TEST_DIR);
+        }
+        else {
+            directory = this.directory();
+            directories.push(`${this.directory()}/__tests__`);
+            directories.push(`${this.directory()}/tests`);
+            directories.push(`${this.directory()}/spec`);
+        }
+        const testFilesFinder = new TestFilesFinder({ directory, directories, processArgs: this.processArgs });
+        const testFiles = await testFilesFinder.findTestFiles();
+        const testRunner = new TestRunner({ configuration: this.getConfiguration(), testFiles });
+        await testRunner.prepare();
+        if (testRunner.getTestsCount() === 0) {
+            throw new Error(`${testRunner.getTestsCount()} tests was found in ${testFiles.length} file(s)`);
+        }
+        await testRunner.run();
+        if (testRunner.isFailed()) {
+            console.error(`\nTest run failed with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`);
+            process.exit(1);
+        }
+        else if (testRunner.areAnyTestsFocussed()) {
+            console.error(`\nFocussed run with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`);
+            process.exit(1);
+        }
+        else {
+            console.log(`\nTest run succeeded with ${testRunner.getSuccessfulTests()} successful tests`);
+            process.exit(0);
+        }
+    }
+}

package/dist/src/environment-handlers/node.d.ts

@@ -0,0 +1,47 @@
+export default class VelociousEnvironmentHandlerNode extends Base {
+    /** @type {import("./base.js").CommandFileObjectType[] | undefined} */
+    _findCommandsResult: import("./base.js").CommandFileObjectType[] | undefined;
+    _actualFindCommands(): Promise<{
+        name: string;
+        file: string;
+    }[]>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsMigrationGenerate(command: import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsMigrationDestroy(command: import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsGenerateBaseModels(command: import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsGenerateModel(command: import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsServer(command: import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    cliCommandsTest(command: import("../cli/base-command.js").default): Promise<any>;
+    _velociousPath: string;
+    /**
+     * @param {string} filePath
+     * @returns {Promise<import("../database/migration/index.js").default>}
+     */
+    requireMigration(filePath: string): Promise<import("../database/migration/index.js").default>;
+    getBasePath(): Promise<string>;
+}
+import Base from "./base.js";
+//# sourceMappingURL=node.d.ts.map

package/dist/src/environment-handlers/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/environment-handlers/node.js"],"names":[],"mappings":"AAgBA;IACE,sEAAsE;IACtE,qBADW,OAAO,WAAW,EAAE,qBAAqB,EAAE,GAAG,SAAS,CACnC;IAa/B;;;SAyBC;IAUD;;;OAGG;IACH,sCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;OAGG;IACH,qCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;OAGG;IACH,uCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;OAGG;IACH,kCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;OAGG;IACH,2BAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;OAGG;IACH,yBAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,GAAG,CAAC,CAIxB;IAwEG,uBAA6D;IAsBjE;;;OAGG;IACH,2BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,gCAAgC,EAAE,OAAO,CAAC,CAUrE;IAED,+BAKC;CACF;iBAhOgB,WAAW"}

package/dist/src/environment-handlers/node.js

@@ -0,0 +1,188 @@
+// @ts-check
+import Base from "./base.js";
+import CliCommandsDestroyMigration from "./node/cli/commands/destroy/migration.js";
+import CliCommandsInit from "./node/cli/commands/init.js";
+import CliCommandsGenerateBaseModels from "./node/cli/commands/generate/base-models.js";
+import CliCommandsGenerateMigration from "./node/cli/commands/generate/migration.js";
+import CliCommandsGenerateModel from "./node/cli/commands/generate/model.js";
+import CliCommandsServer from "./node/cli/commands/server.js";
+import CliCommandsTest from "./node/cli/commands/test.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import fs from "fs/promises";
+import * as inflection from "inflection";
+import path from "path";
+export default class VelociousEnvironmentHandlerNode extends Base {
+    /** @type {import("./base.js").CommandFileObjectType[] | undefined} */
+    _findCommandsResult = undefined;
+    /**
+     * @returns {Promise<Array<import("./base.js").CommandFileObjectType>>}
+     */
+    async findCommands() {
+        this._findCommandsResult ||= await this._actualFindCommands();
+        if (!this._findCommandsResult)
+            throw new Error("Could not get commands");
+        return this._findCommandsResult;
+    }
+    async _actualFindCommands() {
+        const basePath = await this.getBasePath();
+        const commandFiles = fs.glob(`${basePath}/src/cli/commands/**/*.js`);
+        const commands = [];
+        for await (const aFilePath of commandFiles) {
+            const aFilePathParts = aFilePath.split("/");
+            const commandPathLocation = aFilePathParts.indexOf("commands") + 1;
+            const lastPart = aFilePathParts[aFilePathParts.length - 1];
+            let name, paths;
+            if (lastPart == "index.js") {
+                name = aFilePathParts[aFilePathParts.length - 2];
+                paths = aFilePathParts.slice(commandPathLocation, -2);
+            }
+            else {
+                name = lastPart.replace(".js", "");
+                paths = aFilePathParts.slice(commandPathLocation, -1);
+            }
+            const commandName = `${paths.join(":")}${paths.length > 0 ? ":" : ""}${name}`;
+            commands.push({ name: commandName, file: aFilePath });
+        }
+        return commands;
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsInit(command) {
+        return await this.forwardCommand(command, CliCommandsInit);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsMigrationGenerate(command) {
+        return await this.forwardCommand(command, CliCommandsGenerateMigration);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsMigrationDestroy(command) {
+        return await this.forwardCommand(command, CliCommandsDestroyMigration);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsGenerateBaseModels(command) {
+        return await this.forwardCommand(command, CliCommandsGenerateBaseModels);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsGenerateModel(command) {
+        return await this.forwardCommand(command, CliCommandsGenerateModel);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsServer(command) {
+        return await this.forwardCommand(command, CliCommandsServer);
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<any>}
+     */
+    async cliCommandsTest(command) {
+        return await this.forwardCommand(command, CliCommandsTest);
+    }
+    /**
+     * @param {object} args
+     * @param {string[]} args.commandParts
+     * @returns {Promise<typeof import ("../cli/base-command.js").default>}
+     */
+    async requireCommand({ commandParts }) {
+        const commands = await this.findCommands();
+        const command = commands.find((aCommand) => aCommand.name === commandParts.join(":"));
+        if (!command) {
+            const possibleCommands = commands.map(aCommand => aCommand.name);
+            throw new Error(`Unknown command: ${commandParts.join(":")} which should have been one of: ${possibleCommands.sort().join(", ")}`);
+        }
+        const commandClassImport = await import(command.file);
+        const CommandClass = commandClassImport.default;
+        return CommandClass;
+    }
+    /**
+     * @returns {Promise<Array<import("./base.js").MigrationObjectType>>}
+     */
+    async findMigrations() {
+        const migrationsPath = `${this.getConfiguration().getDirectory()}/src/database/migrations`;
+        const glob = await fs.glob(`${migrationsPath}/**/*.js`);
+        let files = [];
+        for await (const fullPath of glob) {
+            const file = await path.basename(fullPath);
+            const match = file.match(/^(\d{14})-(.+)\.js$/);
+            if (!match)
+                continue;
+            const date = parseInt(match[1]);
+            const migrationName = match[2];
+            const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"));
+            files.push({
+                file,
+                fullPath: `${migrationsPath}/${file}`,
+                date,
+                migrationClassName
+            });
+        }
+        files = files.sort((migration1, migration2) => migration1.date - migration2.date);
+        return files;
+    }
+    /**
+     * @returns {Promise<import("../routes/index.js").default>}
+     */
+    async importApplicationRoutes() {
+        const routesImport = await import(`${this.getConfiguration().getDirectory()}/src/config/routes.js`);
+        return routesImport.default;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    async getVelociousPath() {
+        if (!this._velociousPath) {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            this._velociousPath = await fs.realpath(`${__dirname}/../..`);
+        }
+        return this._velociousPath;
+    }
+    /**
+     * @param {string[]} testFiles
+     * @returns {Promise<void>}
+     */
+    async importTestFiles(testFiles) {
+        for (const testFile of testFiles) {
+            await import(testFile);
+        }
+    }
+    async importTestingConfigPath() {
+        const testingConfigPath = this.getConfiguration().getTesting();
+        await import(testingConfigPath);
+    }
+    /**
+     * @param {string} filePath
+     * @returns {Promise<import("../database/migration/index.js").default>}
+     */
+    async requireMigration(filePath) {
+        const migrationImport = await import(filePath);
+        const migrationImportDefault = migrationImport.default;
+        if (!migrationImportDefault)
+            throw new Error("Migration file must export a default migration class");
+        if (typeof migrationImportDefault !== "function")
+            throw new Error("Migration default export isn't a function (should be a class which is a function in JS)");
+        return migrationImportDefault;
+    }
+    async getBasePath() {
+        const __filename = fileURLToPath(import.meta.url);
+        const basePath = await fs.realpath(`${dirname(__filename)}/../..`);
+        return basePath;
+    }
+}

package/dist/src/error-logger.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {(...args: any[]) => Promise<void>} callback
+ */
+export default function errorLogger(callback: (...args: any[]) => Promise<void>): (...args: any[]) => Promise<void>;
+//# sourceMappingURL=error-logger.d.ts.map

package/dist/src/error-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-logger.d.ts","sourceRoot":"","sources":["../../src/error-logger.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,8CAFW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,IAOpB,GAAG,MAHV,GAAG,EAGW,KAFhB,OAAO,CAAC,IAAI,CAAC,CAuB3B"}

package/dist/src/error-logger.js

@@ -0,0 +1,32 @@
+// @ts-check
+/**
+ * @param {(...args: any[]) => Promise<void>} callback
+ */
+export default function errorLogger(callback) {
+    /**
+     * @param  {...any} args
+     * @returns {Promise<void>}
+     */
+    return async function (...args) {
+        try {
+            await callback(...args);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`ErrorLogger: ${error.message}`);
+                if (error.stack) {
+                    console.error("Stack", error.stack);
+                }
+                else {
+                    console.error("No stack");
+                }
+            }
+            else {
+                console.error(`ErrorLogger: ${error}`);
+                console.error("No stack");
+            }
+            // Give console some time to write out messages before crashing
+            setTimeout(() => { throw error; });
+        }
+    };
+}

package/dist/src/http-client/header.d.ts

@@ -0,0 +1,13 @@
+export default class Header {
+    /**
+     * @param {string} name
+     * @param {string | number} value
+     */
+    constructor(name: string, value: string | number);
+    name: string;
+    value: string | number;
+    getName(): string;
+    getValue(): string | number;
+    toString(): string;
+}
+//# sourceMappingURL=header.d.ts.map

package/dist/src/http-client/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/http-client/header.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,MAAM,GAAG,MAAM,EAKzB;IAFC,aAAgB;IAChB,uBAAkB;IAGpB,kBAA8B;IAC9B,4BAAgC;IAChC,mBAA6D;CAC9D"}

package/dist/src/http-client/header.js

@@ -0,0 +1,14 @@
+// @ts-check
+export default class Header {
+    /**
+     * @param {string} name
+     * @param {string | number} value
+     */
+    constructor(name, value) {
+        this.name = name;
+        this.value = value;
+    }
+    getName() { return this.name; }
+    getValue() { return this.value; }
+    toString() { return `${this.getName()}: ${this.getValue()}`; }
+}