velocious 1.0.108 → 1.0.109

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

@@ -0,0 +1,136 @@
+// @ts-check
+/**
+ * @typedef {object} CommandFileObjectType
+ * @property {string} name
+ * @property {string} file
+ */
+/**
+ * @typedef {object} MigrationObjectType
+ * @property {number} date
+ * @property {string} [fullPath]
+ * @property {string} migrationClassName
+ * @property {string} file
+ */
+export default class VelociousEnvironmentHandlerBase {
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsGenerateBaseModels(_command) {
+        throw new Error("cliCommandsGenerateBaseModels not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsInit(command) {
+        throw new Error("cliCommandsInit not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsMigrationGenerate(_command) {
+        throw new Error("cliCommandsMigrationGenerate not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsMigrationDestroy(_command) {
+        throw new Error("cliCommandsMigrationDestroy not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsGenerateModel(_command) {
+        throw new Error("cliCommandsGenerateModel not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsServer(_command) {
+        throw new Error("cliCommandsServer not implemented");
+    }
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    async cliCommandsTest(_command) {
+        throw new Error("cliCommandsTest not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<CommandFileObjectType[]>}
+     */
+    async findCommands() { throw new Error("findCommands not implemented"); }
+    /**
+     * @abstract
+     * @returns {Promise<Array<MigrationObjectType>>}
+     */
+    async findMigrations() { throw new Error("findMigrations not implemneted"); }
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @param {typeof import("../cli/base-command.js").default} CommandClass
+     * @returns {Promise<any>}
+     */
+    async forwardCommand(command, CommandClass) {
+        const newCommand = new CommandClass({
+            args: command.args
+        });
+        return await newCommand.execute();
+    }
+    /**
+     * @abstract
+     * @returns {Promise<string>}
+     */
+    getVelociousPath() { throw new Error("getVelociousPath not implemented"); }
+    /**
+     * @abstract
+     * @returns {Promise<import("../routes/index.js").default>}
+     */
+    async importApplicationRoutes() { throw new Error("importApplicationRoutes not implemented"); }
+    /**
+     * @abstract
+     * @param {string[]} _testFiles
+     * @returns {Promise<void>}
+     */
+    importTestFiles(_testFiles) { throw new Error("'importTestFiles' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    importTestingConfigPath() { throw new Error(`'importTestingConfigPath' not implemented`); }
+    /**
+     * @abstract
+     * @param {object} args
+     * @param {string[]} args.commandParts
+     * @returns {Promise<typeof import ("../cli/base-command.js").default>}
+     */
+    async requireCommand({ commandParts }) { throw new Error("'requireCommand' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @param {object} newArgs
+     * @returns {void}
+     */
+    setArgs(newArgs) { this.args = newArgs; }
+    /**
+     * @param {import("../configuration.js").default} newConfiguration
+     * @returns {void}
+     */
+    setConfiguration(newConfiguration) { this.configuration = newConfiguration; }
+    /**
+     * @returns {import("../configuration.js").default}
+     */
+    getConfiguration() {
+        if (!this.configuration)
+            throw new Error("Configuration hasn't been set");
+        return this.configuration;
+    }
+    /**
+     * @param {string[]} newProcessArgs
+     * @returns {void}
+     */
+    setProcessArgs(newProcessArgs) { this.processArgs = newProcessArgs; }
+}

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

@@ -0,0 +1,65 @@
+/**
+ * @typedef {(id: string) => {default: typeof import("../database/migration/index.js").default}} MigrationsRequireContextIDFunctionType
+ * @typedef {MigrationsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} MigrationsRequireContextType
+ */
+/**
+ * @typedef {(id: string) => {default: typeof import("../cli/base-command.js").default}} CommandsRequireContextIDFunctionType
+ * @typedef {CommandsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} CommandsRequireContextType
+ */
+export default class VelociousEnvironmentsHandlerBrowser extends Base {
+    /**
+     * @param {object} args
+     * @param {() => Promise<MigrationsRequireContextType>} [args.migrationsRequireContextCallback]
+     */
+    constructor({ migrationsRequireContextCallback, ...restArgs }?: {
+        migrationsRequireContextCallback?: () => Promise<MigrationsRequireContextType>;
+    });
+    /** @type {CommandsRequireContextType | undefined} */
+    findCommandsRequireContextResult: CommandsRequireContextType | undefined;
+    /** @type {MigrationsRequireContextType | undefined} */
+    _migrationsRequireContextResult: MigrationsRequireContextType | undefined;
+    migrationsRequireContextCallback: () => Promise<MigrationsRequireContextType>;
+    /**
+     * @returns {Promise<MigrationsRequireContextType>}
+     */
+    migrationsRequireContext(): Promise<MigrationsRequireContextType>;
+    _findCommandsResult: {
+        name: string;
+        file: string;
+    }[];
+    /**
+     * @returns {CommandsRequireContextType}
+     */
+    _findCommandsRequireContext(): CommandsRequireContextType;
+    _actualFindCommands(): {
+        name: string;
+        file: string;
+    }[];
+    /**
+     * @param {string} filePath
+     * @returns {Promise<typeof import("../database/migration/index.js").default>}
+     */
+    requireMigration: (filePath: string) => Promise<typeof import("../database/migration/index.js").default>;
+}
+export type MigrationsRequireContextIDFunctionType = (id: string) => {
+    default: typeof import("../database/migration/index.js").default;
+};
+export type MigrationsRequireContextType = MigrationsRequireContextIDFunctionType & {
+    keys: () => string[];
+    id: string;
+};
+export type CommandsRequireContextIDFunctionType = (id: string) => {
+    default: typeof import("../cli/base-command.js").default;
+};
+export type CommandsRequireContextType = CommandsRequireContextIDFunctionType & {
+    keys: () => string[];
+    id: string;
+};
+import Base from "./base.js";
+//# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/environment-handlers/browser.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;IAOE;;;OAGG;IACH,gEAFG;QAA2D,gCAAgC,GAAnF,MAAM,OAAO,CAAC,4BAA4B,CAAC;KAAyC,EAO9F;IAfD,qDAAqD;IACrD,kCADW,0BAA0B,GAAG,SAAS,CACL;IAE5C,uDAAuD;IACvD,iCADW,4BAA4B,GAAG,SAAS,CACR;IAUzC,wCANe,OAAO,CAAC,4BAA4B,CAAC,CAMoB;IAG1E;;OAEG;IACH,4BAFa,OAAO,CAAC,4BAA4B,CAAC,CAUjD;IAMC;;;QAAqD;IAKvD;;OAEG;IACH,+BAFa,0BAA0B,CAOtC;IAED;;;QAmBC;IAoFD;;;OAGG;IACH,mBAA0B,UAHf,MAGuB,KAFrB,OAAO,CAAC,cAAc,gCAAgC,EAAE,OAAO,CAAC,CAgB5E;CACF;qDA3LY,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,gCAAgC,EAAE,OAAO,CAAA;CAAC;2CAClF,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX;mDAIS,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,wBAAwB,EAAE,OAAO,CAAA;CAAC;yCAC1E,oCAAoC,GAAG;IAC/C,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX;iBAjBa,WAAW"}

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

@@ -0,0 +1,160 @@
+import Base from "./base.js";
+import * as inflection from "inflection";
+import restArgsError from "../utils/rest-args-error.js";
+/**
+ * @typedef {(id: string) => {default: typeof import("../database/migration/index.js").default}} MigrationsRequireContextIDFunctionType
+ * @typedef {MigrationsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} MigrationsRequireContextType
+ */
+/**
+ * @typedef {(id: string) => {default: typeof import("../cli/base-command.js").default}} CommandsRequireContextIDFunctionType
+ * @typedef {CommandsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} CommandsRequireContextType
+ */
+export default class VelociousEnvironmentsHandlerBrowser extends Base {
+    /** @type {CommandsRequireContextType | undefined} */
+    findCommandsRequireContextResult = undefined;
+    /** @type {MigrationsRequireContextType | undefined} */
+    _migrationsRequireContextResult = undefined;
+    /**
+     * @param {object} args
+     * @param {() => Promise<MigrationsRequireContextType>} [args.migrationsRequireContextCallback]
+     */
+    constructor({ migrationsRequireContextCallback, ...restArgs } = {}) {
+        super();
+        restArgsError(restArgs);
+        this.migrationsRequireContextCallback = migrationsRequireContextCallback;
+    }
+    /**
+     * @returns {Promise<MigrationsRequireContextType>}
+     */
+    async migrationsRequireContext() {
+        const { migrationsRequireContextCallback } = this;
+        if (!migrationsRequireContextCallback)
+            throw new Error("migrationsRequireContextCallback is required");
+        this._migrationsRequireContextResult ||= await migrationsRequireContextCallback();
+        return this._migrationsRequireContextResult;
+    }
+    /**
+     * @returns {Promise<Array<import("./base.js").CommandFileObjectType>>}
+     */
+    async findCommands() {
+        this._findCommandsResult = this._actualFindCommands();
+        return this._findCommandsResult;
+    }
+    /**
+     * @returns {CommandsRequireContextType}
+     */
+    _findCommandsRequireContext() {
+        // @ts-expect-error
+        this.findCommandsRequireContextResult ||= /** @type {CommandsRequireContextType} */ (require.context("../cli/commands", true, /\.js$/));
+        return this.findCommandsRequireContextResult;
+    }
+    _actualFindCommands() {
+        const commandFiles = this._findCommandsRequireContext();
+        const commands = [];
+        for (const aFilePath of commandFiles.keys()) {
+            const aFilePathParts = aFilePath.split("/");
+            const lastPart = aFilePathParts[aFilePathParts.length - 1];
+            let name;
+            if (lastPart == "index.js") {
+                name = aFilePathParts[aFilePathParts.length - 2];
+            }
+            else {
+                name = lastPart.replace(".js", "");
+            }
+            commands.push({ name, file: aFilePath });
+        }
+        return commands;
+    }
+    /**
+     * @param {object} args
+     * @param {Array<string>} args.commandParts
+     * @returns {Promise<typeof import("../cli/base-command.js").default>}
+     */
+    async requireCommand({ commandParts }) {
+        let filePath = ".";
+        for (let commandPart of commandParts) {
+            if (commandPart == "d")
+                commandPart = "destroy";
+            if (commandPart == "g")
+                commandPart = "generate";
+            if (commandPart == "s")
+                commandPart = "server";
+            filePath += `/${commandPart}`;
+        }
+        const filePaths = [];
+        filePaths.push(`${filePath}/index.js`);
+        filePath += ".js";
+        filePaths.push(filePath);
+        const commandsRequireContext = await this._findCommandsRequireContext();
+        let commandClassImport;
+        for (const aFilePath of filePaths) {
+            commandClassImport = commandsRequireContext(aFilePath);
+            if (commandClassImport) {
+                break;
+            }
+        }
+        if (!commandClassImport) {
+            throw new Error(`Unknown command: ${commandParts.join(":")}. Possible commands: ${commandsRequireContext.keys()}`);
+        }
+        const CommandClass = commandClassImport.default;
+        return CommandClass;
+    }
+    /**
+     * @returns {Promise<Array<import("./base.js").MigrationObjectType>>}
+     */
+    async findMigrations() {
+        const migrationsRequireContext = await this.migrationsRequireContext();
+        const files = migrationsRequireContext
+            .keys()
+            .map((file) => {
+            // "13,14" because somes "require-context"-npm-module deletes first character!?
+            const match = file.match(/(\d{13,14})-(.+)\.js$/);
+            if (!match)
+                return null;
+            // Fix require-context-npm-module deletes first character
+            let fileName = file;
+            let dateNumber = match[1];
+            if (dateNumber.length == 13) {
+                dateNumber = `2${dateNumber}`;
+                fileName = `2${fileName}`;
+            }
+            // Parse regex
+            const date = parseInt(dateNumber);
+            const migrationName = match[2];
+            const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"));
+            return {
+                file: fileName,
+                fullPath: file,
+                date,
+                migrationClassName
+            };
+        })
+            .filter((migration) => Boolean(migration))
+            .sort((migration1, migration2) => migration1.date - migration2.date);
+        return files;
+    }
+    /**
+     * @param {string} filePath
+     * @returns {Promise<typeof import("../database/migration/index.js").default>}
+     */
+    requireMigration = async (filePath) => {
+        if (!filePath)
+            throw new Error("filePath is required");
+        const migrationsRequireContext = await this.migrationsRequireContext();
+        const migrationImport = migrationsRequireContext(filePath);
+        if (!migrationImport)
+            throw new Error(`Migration file ${filePath} not found`);
+        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;
+    };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @typedef {{destroyed: string[]}} DestroyMigrationResult
+ */
+export default class DbDestroyMigration extends BaseCommand {
+    /**
+     * @returns {Promise<void | DestroyMigrationResult>}
+     */
+    execute(): Promise<void | DestroyMigrationResult>;
+}
+export type DestroyMigrationResult = {
+    destroyed: string[];
+};
+import BaseCommand from "../../../../../cli/base-command.js";
+//# sourceMappingURL=migration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/destroy/migration.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;IACE;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG,sBAAsB,CAAC,CA+BlD;CACF;qCArCY;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAC;wBAJV,oCAAoC"}

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

@@ -0,0 +1,34 @@
+import BaseCommand from "../../../../../cli/base-command.js";
+import fs from "fs/promises";
+/**
+ * @typedef {{destroyed: string[]}} DestroyMigrationResult
+ */
+export default class DbDestroyMigration extends BaseCommand {
+    /**
+     * @returns {Promise<void | DestroyMigrationResult>}
+     */
+    async execute() {
+        const migrationName = this.processArgs[1];
+        const migrationDir = `${this.getConfiguration().getDirectory()}/src/database/migrations`;
+        const migrationFiles = await fs.readdir(migrationDir);
+        const destroyed = [];
+        for (const migrationFile of migrationFiles) {
+            const match = migrationFile.match(/^(\d{14})-(.+)\.js$/);
+            if (!match) {
+                continue;
+            }
+            const fileName = match[2];
+            if (fileName != migrationName)
+                continue;
+            const fullFilePath = `${migrationDir}/${migrationFile}`;
+            destroyed.push(fileName);
+            if (!this.args.testing) {
+                console.log(`Destroy src/database/migrations/${migrationFile}`);
+                await fs.unlink(fullFilePath);
+            }
+        }
+        if (this.args.testing) {
+            return { destroyed };
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class DbGenerateModel extends BaseCommand {
+    execute(): Promise<void>;
+    /**
+     * @param {import("../../../../../database/drivers/base-column.js").default} column
+     * @returns {string | undefined}
+     */
+    jsDocTypeFromColumn(column: import("../../../../../database/drivers/base-column.js").default): string | undefined;
+}
+import BaseCommand from "../../../../../cli/base-command.js";
+//# sourceMappingURL=base-models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-models.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/base-models.js"],"names":[],"mappings":"AAKA;IACE,yBA4OC;IAED;;;OAGG;IACH,4BAHW,OAAO,gDAAgD,EAAE,OAAO,GAC9D,MAAM,GAAG,SAAS,CAU9B;CACF;wBAjQuB,oCAAoC"}

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

@@ -0,0 +1,219 @@
+import BaseCommand from "../../../../../cli/base-command.js";
+import fileExists from "../../../../../utils/file-exists.js";
+import fs from "fs/promises";
+import * as inflection from "inflection";
+export default class DbGenerateModel extends BaseCommand {
+    async execute() {
+        await this.getConfiguration().initializeModels();
+        const modelsDir = `${process.cwd()}/src/model-bases`;
+        const modelClasses = this.getConfiguration().getModelClasses();
+        let devMode = false;
+        if (modelsDir.endsWith("velocious/spec/dummy/src/model-bases")) {
+            devMode = true;
+        }
+        if (!await fileExists(modelsDir)) {
+            await fs.mkdir(modelsDir, { recursive: true });
+        }
+        for (const modelClassName in modelClasses) {
+            const modelClass = modelClasses[modelClassName];
+            const modelName = inflection.dasherize(modelClassName);
+            const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"));
+            const modelBaseFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`;
+            const modelPath = `${modelsDir}/${modelBaseFileName}`;
+            console.log(`create src/model-bases/${modelBaseFileName}`);
+            let fileContent = "";
+            let velociousPath = "velocious";
+            if (devMode) {
+                velociousPath = "../../../..";
+                fileContent += `import DatabaseRecord from "../../../../src/database/record/index.js"\n\n`;
+                // /** @type {import("./instance-relationships/has-many.js").default} */
+            }
+            else {
+                fileContent += `import DatabaseRecord from "velocious/dist/src/database/record/index.js"\n\n`;
+            }
+            const hasManyRelationFilePath = `${velociousPath}/src/database/record/instance-relationships/has-many.js`;
+            fileContent += `export default class ${modelNameCamelized}Base extends DatabaseRecord {\n`;
+            const columns = await modelClass._getTable().getColumns();
+            let methodsCount = 0;
+            for (const column of columns) {
+                const camelizedColumnName = inflection.camelize(column.getName(), true);
+                const camelizedColumnNameBigFirst = inflection.camelize(column.getName());
+                const jsdocType = this.jsDocTypeFromColumn(column);
+                if (methodsCount > 0) {
+                    fileContent += "\n";
+                }
+                if (jsdocType) {
+                    fileContent += "  /**\n";
+                    fileContent += `   * @returns {${jsdocType}${column.getNull() ? " | null" : ""}}\n`;
+                    fileContent += "   */\n";
+                }
+                fileContent += `  ${camelizedColumnName}() { return this.readAttribute("${camelizedColumnName}") }\n\n`;
+                if (jsdocType) {
+                    fileContent += "  /**\n";
+                    fileContent += `   * @param {${jsdocType}${column.getNull() ? " | null" : ""}} newValue\n`;
+                    fileContent += "   * @returns {void}\n";
+                    fileContent += "   */\n";
+                }
+                fileContent += `  set${camelizedColumnNameBigFirst}(newValue) { return this._setColumnAttribute("${camelizedColumnName}", newValue) }\n\n`;
+                fileContent += "  /**\n";
+                fileContent += "   * @returns {boolean}\n";
+                fileContent += "   */\n";
+                fileContent += `  has${camelizedColumnNameBigFirst}() { return this._hasAttribute(this.${camelizedColumnName}()) }\n`;
+                methodsCount++;
+            }
+            if (modelClass._translations) {
+                const TranslationClass = modelClass.getTranslationClass();
+                const translationColumns = TranslationClass.getColumns();
+                for (const name in modelClass._translations) {
+                    const nameUnderscore = inflection.underscore(name);
+                    const column = translationColumns.find((translationColumn) => translationColumn.getName() === nameUnderscore);
+                    let translationJsdocType;
+                    if (column) {
+                        translationJsdocType = this.jsDocTypeFromColumn(column);
+                    }
+                    if (translationJsdocType) {
+                        fileContent += `\n`;
+                        fileContent += "  /**\n";
+                        fileContent += `   * @returns {${translationJsdocType}${column.getNull() ? " | null" : ""}}\n`;
+                        fileContent += "   */\n";
+                    }
+                    fileContent += `  ${name}() { return this._getTranslatedAttributeWithFallback("${name}", this._getConfiguration().getLocale()) }\n`;
+                    methodsCount++;
+                    const hasName = `has${inflection.camelize(name)}`;
+                    fileContent += `\n`;
+                    fileContent += "  /**\n";
+                    fileContent += `   * @abstract\n`;
+                    fileContent += `   * @returns {boolean}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  ${hasName}() { throw new Error("${hasName} not implemented") }\n`;
+                    methodsCount++;
+                    for (const locale of this.getConfiguration().getLocales()) {
+                        const localeMethodName = `${name}${inflection.camelize(locale)}`;
+                        if (translationJsdocType) {
+                            fileContent += `\n`;
+                            fileContent += "  /**\n";
+                            fileContent += `   * @returns {${translationJsdocType}${column.getNull() ? " | null" : ""}}\n`;
+                            fileContent += "   */\n";
+                        }
+                        fileContent += `  ${localeMethodName}() { return this._getTranslatedAttributeWithFallback("${name}", "${locale}") }\n`;
+                        methodsCount++;
+                        const localeHasName = `has${inflection.camelize(localeMethodName)}`;
+                        fileContent += `\n`;
+                        fileContent += "  /**\n";
+                        fileContent += `   * @abstract\n`;
+                        fileContent += `   * @returns {boolean}\n`;
+                        fileContent += "   */\n";
+                        fileContent += `  ${localeHasName}() { throw new Error("${localeHasName} not implemented") }\n`;
+                        methodsCount++;
+                    }
+                }
+            }
+            for (const relationship of modelClass.getRelationships()) {
+                let baseFilePath, baseFullFilePath, fileName, fullFilePath;
+                if (relationship.getPolymorphic()) {
+                    fileName = "velocious/dist/src/database/record/index.js";
+                }
+                else {
+                    fileName = inflection.dasherize(inflection.underscore(relationship.getTargetModelClass().name));
+                    fullFilePath = `src/models/${fileName}.js`;
+                    baseFilePath = `../model-bases/${fileName}.js`;
+                    baseFullFilePath = `src/model-bases/${fileName}.js`;
+                }
+                if (methodsCount > 0) {
+                    fileContent += "\n";
+                }
+                if (relationship.getType() == "belongsTo" || relationship.getType() == "hasOne") {
+                    let modelFilePath;
+                    if (fullFilePath && await fileExists(fullFilePath)) {
+                        modelFilePath = `../models/${fileName}.js`;
+                    }
+                    else if (baseFullFilePath && await fileExists(baseFullFilePath)) {
+                        modelFilePath = baseFilePath;
+                    }
+                    else {
+                        modelFilePath = "velocious/dist/src/database/record/index.js";
+                    }
+                    fileContent += "  /**\n";
+                    fileContent += `   * @returns {import("${modelFilePath}").default}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  ${relationship.getRelationshipName()}() { return /** @type {import("${modelFilePath}").default} */ (this.getRelationshipByName("${relationship.getRelationshipName()}").loaded()) }\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += "   * @abstract\n";
+                    fileContent += "   * @param {Record<string, any>} attributes\n";
+                    fileContent += `   * @returns {import("${modelFilePath}").default}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  build${inflection.camelize(relationship.getRelationshipName())}(attributes) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += "   * @abstract\n";
+                    fileContent += "   * @returns {Promise<void>}\n";
+                    fileContent += "   */\n";
+                    fileContent += `  load${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += "   * @abstract\n";
+                    fileContent += `   * @param {import("${modelFilePath}").default} newModel\n`;
+                    fileContent += `   * @returns {void}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}(newModel) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`;
+                }
+                else if (relationship.getType() == "hasMany") {
+                    let recordImport;
+                    if (fullFilePath && await fileExists(fullFilePath)) {
+                        recordImport = `../models/${fileName}.js`;
+                    }
+                    else if (baseFullFilePath && await fileExists(baseFullFilePath)) {
+                        recordImport = `../model-bases/${fileName}.js`;
+                    }
+                    else {
+                        recordImport = `${velociousPath}/src/database/record/index.js`;
+                    }
+                    fileContent += "  /**\n";
+                    fileContent += `   * @returns {import("${hasManyRelationFilePath}").default}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  ${relationship.getRelationshipName()}() { return /** @type {import("${hasManyRelationFilePath}").default} */ (this.getRelationshipByName("${relationship.getRelationshipName()}")) }\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += `   * @returns {Array<import("${recordImport}").default>}\n`;
+                    fileContent += "   */\n";
+                    fileContent += `  ${relationship.getRelationshipName()}Loaded() { return /** @type {Array<import("${recordImport}").default>} */ (this.getRelationshipByName("${relationship.getRelationshipName()}").loaded()) }\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += "   * @abstract\n";
+                    fileContent += "   * @returns {Promise<void>}\n";
+                    fileContent += "   */\n";
+                    fileContent += `  load${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`;
+                    fileContent += "\n";
+                    fileContent += "  /**\n";
+                    fileContent += "   * @abstract\n";
+                    fileContent += `   * @param {Array<import("${recordImport}").default>} newModels\n`;
+                    fileContent += "   * @returns {void}\n";
+                    fileContent += "   */\n";
+                    fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}(newModels) { throw new Error("Not implemented") } // eslint-disable-line no-unused-vars\n`;
+                }
+                else {
+                    throw new Error(`Unknown relationship type: ${relationship.getType()}`);
+                }
+                methodsCount++;
+            }
+            fileContent += "}\n";
+            await fs.writeFile(modelPath, fileContent);
+        }
+    }
+    /**
+     * @param {import("../../../../../database/drivers/base-column.js").default} column
+     * @returns {string | undefined}
+     */
+    jsDocTypeFromColumn(column) {
+        if (column.getType() == "varchar") {
+            return "string";
+        }
+        else if (["bigint", "int", "integer", "smallint"].includes(column.getType())) {
+            return "number";
+        }
+        else if (["date", "datetime"].includes(column.getType())) {
+            return "Date";
+        }
+    }
+}