velocious 1.0.5 → 1.0.7

package/src/cli/commands/destroy/{migration.mjs → migration.js}

@@ -1,4 +1,4 @@
-import BaseCommand from "../../base-command.mjs"
+import BaseCommand from "../../base-command.js"
 import fs from "node:fs/promises"
 
 export default class DbDestroyMigration extends BaseCommand {
@@ -9,7 +9,7 @@ export default class DbDestroyMigration extends BaseCommand {
     const destroyed = []
 
     for (const migrationFile of migrationFiles) {
-      const match = migrationFile.match(/^(\d{14})-(.+)\.mjs$/)
+      const match = migrationFile.match(/^(\d{14})-(.+)\.js$/)
 
       if (!match) {
         continue

package/src/cli/commands/generate/{migration.mjs → migration.js}

@@ -1,9 +1,9 @@
-import BaseCommand from "../../base-command.mjs"
+import BaseCommand from "../../base-command.js"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
-import fileExists from "../../../utils/file-exists.mjs"
+import fileExists from "../../../utils/file-exists.js"
 import fs from "node:fs/promises"
-import inflection from "inflection"
+import * as inflection from "inflection"
 import strftime from "strftime"
 
 export default class DbGenerateMigration extends BaseCommand {
@@ -12,10 +12,10 @@ export default class DbGenerateMigration extends BaseCommand {
     const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))
     const date = new Date()
     const migrationNumber = strftime("%Y%m%d%H%M%S")
-    const migrationFileName = `${migrationNumber}-${migrationName}.mjs`
+    const migrationFileName = `${migrationNumber}-${migrationName}.js`
     const __filename = fileURLToPath(`${import.meta.url}/../../..`)
     const __dirname = dirname(__filename)
-    const templateFilePath = `${__dirname}/templates/generate-migration.mjs`
+    const templateFilePath = `${__dirname}/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`

package/src/cli/commands/generate/{model.mjs → model.js}

@@ -1,19 +1,19 @@
-import BaseCommand from "../../base-command.mjs"
+import BaseCommand from "../../base-command.js"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
-import fileExists from "../../../utils/file-exists.mjs"
+import fileExists from "../../../utils/file-exists.js"
 import fs from "node:fs/promises"
-import inflection from "inflection"
+import * as inflection from "inflection"
 
 export default class DbGenerateModel extends BaseCommand {
   async execute() {
     const modelName = this.processArgs[1]
     const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
     const date = new Date()
-    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.mjs`
+    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
     const __filename = fileURLToPath(`${import.meta.url}/../../..`)
     const __dirname = dirname(__filename)
-    const templateFilePath = `${__dirname}/templates/generate-model.mjs`
+    const templateFilePath = `${__dirname}/templates/generate-model.js`
     const modelContentBuffer = await fs.readFile(templateFilePath)
     const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized)
     const modelsDir = `${process.cwd()}/src/models`

package/src/cli/commands/{init.mjs → init.js}

@@ -1,6 +1,6 @@
-import BaseCommand from "../base-command.mjs"
+import BaseCommand from "../base-command.js"
 import {dirname} from "path"
-import fileExists from "../../utils/file-exists.mjs"
+import fileExists from "../../utils/file-exists.js"
 import {fileURLToPath} from "url"
 import fs from "node:fs/promises"
 
@@ -12,12 +12,12 @@ export default class VelociousCliCommandsInit extends BaseCommand {
     const projectConfigPath = `${projectPath}/src/config`
     const fileMappings = [
       {
-        source: `${velocipusPath}/src/templates/configuration.mjs`,
-        target: `${projectConfigPath}/configuration.mjs`
+        source: `${velocipusPath}/src/templates/configuration.js`,
+        target: `${projectConfigPath}/configuration.js`
       },
       {
-        source: `${velocipusPath}/src/templates/routes.mjs`,
-        target: `${projectConfigPath}/routes.mjs`
+        source: `${velocipusPath}/src/templates/routes.js`,
+        target: `${projectConfigPath}/routes.js`
       }
     ]
     const paths = [

package/src/cli/commands/{server.mjs → server.js}

@@ -1,4 +1,4 @@
-import BaseCommand from "../base-command.mjs"
+import BaseCommand from "../base-command.js"
 
 export default class DbCreate extends BaseCommand{
   async execute() {

package/src/cli/commands/test/{index.mjs → index.js}

@@ -1,6 +1,6 @@
-import BaseCommand from "../../base-command.mjs"
-import TestFilesFinder from "./test-files-finder.mjs"
-import TestRunner from "./test-runner.mjs"
+import BaseCommand from "../../base-command.js"
+import TestFilesFinder from "./test-files-finder.js"
+import TestRunner from "./test-runner.js"
 
 export default class VelociousCliCommandsInit extends BaseCommand {
   async execute() {

package/src/cli/commands/test/{test-files-finder.mjs → test-files-finder.js}

@@ -90,7 +90,7 @@ export default class TestFilesFinder {
           return true
         }
       }
-    } else if (file.match(/-spec\.mjs/)) {
+    } else if (file.match(/-spec\.js/)) {
       return true
     }
 

package/src/cli/{index.mjs → index.js}

@@ -1,7 +1,7 @@
-import configurationResolver from "../configuration-resolver.mjs"
+import configurationResolver from "../configuration-resolver.js"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
-import fileExists from "../utils/file-exists.mjs"
+import fileExists from "../utils/file-exists.js"
 
 export default class VelociousCli {
   constructor(args = {}) {
@@ -23,8 +23,8 @@ export default class VelociousCli {
       filePath += `/${commandPart}`
     }
 
-    filePaths.push(`${filePath}/index.mjs`)
-    filePath += ".mjs"
+    filePaths.push(`${filePath}/index.js`)
+    filePath += ".js"
     filePaths.push(filePath)
 
     let fileFound

package/src/{configuration-resolver.mjs → configuration-resolver.js}

@@ -1,4 +1,4 @@
-import Configuration from "./configuration.mjs"
+import Configuration from "./configuration.js"
 
 const configurationResolver = async (args) => {
   if (Configuration.current(false)) {
@@ -6,7 +6,7 @@ const configurationResolver = async (args) => {
   }
 
   const directory = args.directory || process.cwd()
-  const configurationPath = `${directory}/src/config/configuration.mjs`
+  const configurationPath = `${directory}/src/config/configuration.js`
   let configuration
 
   try {

package/src/{configuration.mjs → configuration.js}

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousConfiguration {
   static current(throwError = true) {
@@ -7,10 +8,19 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({database, debug, directory}) {
+  constructor({database, debug, directory, initializeModels, locale, locales, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!initializeModels) throw new Error("initializeModels wasn't given")
+
     this.database = database
     this.debug = debug
     this._directory = directory
+    this._initializeModels = initializeModels
+    this._isInitialized = false
+    this.locale = locale
+    this.locales = locales
+    this.modelClasses = {}
   }
 
   getDatabasePool() {
@@ -39,6 +49,26 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  getLocale() {
+    if (typeof this.locale == "function") {
+      return this.locale()
+    } else if (this.locale) {
+      return this.locale
+    } else {
+      return this.getLocales()[0]
+    }
+  }
+
+  getLocales = () => digg(this, "locales")
+
+  getModelClass(name) {
+    const modelClass = this.modelClasses[name]
+
+    if (!modelClass) throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(", ")}}`)
+
+    return modelClass
+  }
+
   initializeDatabasePool() {
     if (!this.database) throw new Error("No 'database' was given")
     if (this.databasePool) throw new Error("DatabasePool has already been initialized")
@@ -50,9 +80,15 @@ export default class VelociousConfiguration {
   }
 
   isDatabasePoolInitialized = () => Boolean(this.databasePool)
+  isInitialized = () => this._isInitialized
+
+  async initialize() {
+    await this._initializeModels({configuration: this})
+    this._isInitialized = true
+  }
 
-  initialize() {
-    // Doesn't currently do anything.
+  registerModelClass(modelClass) {
+    this.modelClasses[modelClass.name] = modelClass
   }
 
   setCurrent() {

package/src/database/drivers/{base.mjs → base.js}

@@ -1,5 +1,5 @@
-import Query from "../query/index.mjs"
-import Handler from "../handler.mjs"
+import Query from "../query/index.js"
+import Handler from "../handler.js"
 
 export default class VelociousDatabaseDriversBase {
   constructor(args) {
@@ -7,9 +7,11 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async createTable(...args) {
-    const sql = this.createTableSql(...args)
+    const sqls = this.createTableSql(...args)
 
-    await this.query(sql)
+    for (const sql of sqls) {
+      await this.query(sql)
+    }
   }
 
   async delete(...args) {
@@ -26,12 +28,29 @@ export default class VelociousDatabaseDriversBase {
     return this.idSeq
   }
 
+  getTables() {
+    throw new Error(`${this.constructor.name}#getTables not implemented`)
+  }
+
+  async getTableByName(name) {
+    const tables = await this.getTables()
+    const table = tables.find((table) => table.getName() == name)
+
+    if (!table) throw new Error(`Couldn't find a table by that name: ${name}`)
+
+    return table
+  }
+
   async insert(...args) {
     const sql = this.insertSql(...args)
 
     await this.query(sql)
   }
 
+  lastInsertID() {
+    throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
+  }
+
   async select(tableName) {
     const handler = new Handler()
     const query = new Query({

package/src/database/drivers/mysql/column.js

@@ -0,0 +1,8 @@
+export default class VelociousDatabaseDriversMysqlColumn {
+  constructor(table, data) {
+    this.data = data
+    this.table = table
+  }
+
+  getName = () => this.data["Field"]
+}

package/src/database/drivers/mysql/{index.mjs → index.js}

@@ -1,15 +1,16 @@
-import Base from "../base.mjs"
-import connectConnection from "./connect-connection.mjs"
-import CreateDatabase from "./sql/create-database.mjs"
-import CreateTable from "./sql/create-table.mjs"
-import Delete from "./sql/delete.mjs"
+import Base from "../base.js"
+import connectConnection from "./connect-connection.js"
+import CreateDatabase from "./sql/create-database.js"
+import CreateTable from "./sql/create-table.js"
+import Delete from "./sql/delete.js"
 import {digg} from "diggerize"
-import Insert from "./sql/insert.mjs"
-import Options from "./options.mjs"
+import Insert from "./sql/insert.js"
+import Options from "./options.js"
 import mysql from "mysql"
-import query from "./query.mjs"
-import QueryParser from "./query-parser.mjs"
-import Update from "./sql/update.mjs"
+import query from "./query.js"
+import QueryParser from "./query-parser.js"
+import Table from "./table.js"
+import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversMysql extends Base{
   async connect() {
@@ -64,13 +65,25 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return new QueryParser({query}).toSql()
   }
 
-  quote(string) {
+  escape(string) {
     if (!this.connection) throw new Error("Can't escape before connected")
 
     return this.connection.escape(string)
   }
 
-  quoteColumn(string) {
+  quote(string) {
+    return `${this.escape(string)}`
+  }
+
+  quoteColumn = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `\`${string}\``
+  }
+
+  quoteTable = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
     return `\`${string}\``
   }
 
@@ -86,6 +99,25 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return insert.toSql()
   }
 
+  async getTables() {
+    const result = await this.query("SHOW FULL TABLES")
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table(this, row)
+
+      tables.push(table)
+    }
+
+    return tables
+  }
+
+  async lastInsertID() {
+    const result = await this.query("SELECT LAST_INSERT_ID() AS last_insert_id")
+
+    return digg(result, 0, "last_insert_id")
+  }
+
   options() {
     if (!this._options) {
       this._options = new Options({driver: this})

package/src/database/drivers/{sqlite/options.mjs → mysql/options.js}

@@ -1,8 +1,9 @@
-import QueryParserOptions from "../../query-parser/options.mjs"
+import QueryParserOptions from "../../query-parser/options.js"
 
 export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
   constructor(options) {
     options.columnQuote = "`"
+    options.indexQuote = "`"
     options.stringQuote = "'"
     options.tableQuote = "`"
 

package/src/database/drivers/mysql/query-parser.js

@@ -0,0 +1,4 @@
+import BaseQueryParser from "../../query-parser/base-query-parser.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlQueryParser extends BaseQueryParser {
+}

package/src/database/drivers/mysql/sql/{create-database.mjs → create-database.js}

@@ -1,4 +1,4 @@
-import CreateDatabaseBase from "../../../query/create-database-base.mjs"
+import CreateDatabaseBase from "../../../query/create-database-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlCreateDatabase extends CreateDatabaseBase {
 }

package/src/database/drivers/{sqlite/sql/create-table.mjs → mysql/sql/create-table.js}

@@ -1,4 +1,4 @@
-import CreateTableBase from "../../../query/create-table-base.mjs"
+import CreateTableBase from "../../../query/create-table-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
 }

package/src/database/drivers/mysql/sql/{delete.mjs → delete.js}

@@ -1,4 +1,4 @@
-import DeleteBase from "../../../query/delete-base.mjs"
+import DeleteBase from "../../../query/delete-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends DeleteBase {
   toSql() {

package/src/database/drivers/{sqlite/sql/insert.mjs → mysql/sql/insert.js}

@@ -1,4 +1,4 @@
-import InsertBase from "../../../query/insert-base.mjs"
+import InsertBase from "../../../query/insert-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlInsert extends InsertBase {
   toSql() {

package/src/database/drivers/mysql/sql/{update.mjs → update.js}

@@ -1,4 +1,4 @@
-import UpdateBase from "../../../query/update-base.mjs"
+import UpdateBase from "../../../query/update-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends UpdateBase {
   toSql() {

package/src/database/drivers/mysql/table.js

@@ -0,0 +1,25 @@
+import Column from "./column.js"
+
+export default class VelociousDatabaseDriversMysqlTable {
+  constructor(driver, data) {
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    const result = await this.driver.query(`SHOW FULL COLUMNS FROM \`${this.getName()}\``)
+    const columns = []
+
+    for (const data of result) {
+      const column = new Column(this, data)
+
+      columns.push(column)
+    }
+
+    return columns
+  }
+
+  getName() {
+    return Object.values(this.data)[0]
+  }
+}

package/src/database/drivers/sqlite/base.js

@@ -0,0 +1,108 @@
+import {digg} from "diggerize"
+
+import Base from "../base.js"
+import CreateIndex from "../sqlite/sql/create-index.js"
+import CreateTable from "../sqlite/sql/create-table.js"
+import Delete from "../sqlite/sql/delete.js"
+import escapeString from "sql-string-escape"
+import Insert from "../sqlite/sql/insert.js"
+import Options from "../sqlite/options.js"
+import QueryParser from "../sqlite/query-parser.js"
+import Table from "./table"
+import Update from "../sqlite/sql/update.js"
+
+export default class VelociousDatabaseDriversSqliteBase extends Base {
+  createIndexSql(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return createIndex.toSql()
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
+  insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
+
+  async getTableByName(tableName) {
+    const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(tableName)} LIMIT 1`)
+    const row = result[0]
+
+    if (!row) {
+      const tables = await this.getTables()
+      const tableNames = tables.map((table) => table.getName())
+
+      throw new Error(`No table by that name: ${tableName} in ${tableNames.join(", ")}`)
+    }
+
+    return new Table({driver: this, row})
+  }
+
+  async getTables() {
+    const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table({driver: this, row})
+
+      tables.push(table)
+    }
+
+    return tables
+  }
+
+  async lastInsertID() {
+    const result = await this.query("SELECT LAST_INSERT_ROWID() AS last_insert_id")
+
+    return digg(result, 0, "last_insert_id")
+  }
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+
+  queryToSql = (query) => new QueryParser({query}).toSql()
+
+  escape(value) {
+    const type = typeof value
+
+    if (type != "string") value = `${value}`
+
+    const resultWithQuotes = escapeString(value)
+    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)
+
+    return result
+  }
+
+  quote(value) {
+    const type = typeof value
+
+    if (type == "number") return value
+    if (type != "string") value = `${value}`
+
+    return escapeString(value)
+  }
+
+  quoteColumn = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `\`${string}\``
+  }
+
+  quoteTable = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
+    return `\`${string}\``
+  }
+
+  updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
+}

package/src/database/drivers/sqlite/column.js

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversSqliteColumn {
+  constructor({column, driver}) {
+    this.column = column
+    this.driver = driver
+  }
+
+  getName = () => digg(this, "column", "name")
+}

package/src/database/drivers/sqlite/{index.native.mjs → index.native.js}

@@ -1,19 +1,31 @@
-import Base from "./base"
 import {digg} from "diggerize"
-import escapeString from "sql-string-escape"
-import Options from "../sqlite/options.mjs"
 import query from "./query"
 import * as SQLite from "expo-sqlite"
 
+import Base from "./base"
+
 export default class VelociousDatabaseDriversSqliteNative extends Base {
   async connect() {
-    const connection = await SQLite.openDatabaseAsync(digg(this.getArgs(), "name"))
+    const args = this.getArgs()
+    const databaseName = digg(args, "name")
+
+    if (args.reset) {
+      try {
+        await SQLite.deleteDatabaseAsync(databaseName)
+      } catch (error) {
+        if (error.message.match(/Database '(.+)' not found/)) {
+          // Ignore not found
+        } else {
+          throw error
+        }
+      }
+    }
 
-    this.connection = connection
+    this.connection = await SQLite.openDatabaseAsync(databaseName)
   }
 
-  disconnect() {
-    this.connection.end()
+  async disconnect() {
+    await this.connection.closeAsync()
   }
 
   connectArgs() {
@@ -36,19 +48,4 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
   }
 
   query = async (sql) => await query(this.connection, sql)
-
-  quote(string) {
-    const type = typeof string
-
-    if (type == "number") return string
-    if (type != "string") string = `${string}`
-
-    return escapeString(string)
-  }
-
-  options() {
-    if (!this._options) this._options = new Options({driver: this})
-
-    return this._options
-  }
 }