velocious 1.0.108 → 1.0.110

package/src/environment-handlers/base.js

@@ -1,158 +0,0 @@
-// @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) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsGenerateBaseModels not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsInit(command) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsInit not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} _command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsMigrationGenerate(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsMigrationGenerate not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} _command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsMigrationDestroy(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsMigrationDestroy not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} _command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsGenerateModel(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsGenerateModel not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} _command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsServer(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("cliCommandsServer not implemented")
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} _command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsTest(_command) { // eslint-disable-line no-unused-vars
-    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/src/environment-handlers/browser.js

@@ -1,193 +0,0 @@
-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/src/environment-handlers/node/cli/commands/destroy/migration.js

@@ -1,42 +0,0 @@
-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/src/environment-handlers/node/cli/commands/generate/base-models.js

@@ -1,258 +0,0 @@
-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/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/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/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"
-    }
-  }
-}

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

@@ -1,40 +0,0 @@
-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}`)
-    }
-  }
-}