velocious 1.0.102 → 1.0.104

package/src/database/drivers/sqlite/sql/alter-table.js

@@ -1,12 +1,17 @@
+// @ts-check
+
 import AlterTableBase from "../../../query/alter-table-base.js"
 import CreateIndexBase from "../../../query/create-index-base.js"
-import {digs} from "diggerize"
-import * as inflection from "inflection"
 import {Logger} from "../../../../logger.js"
 import restArgsError from "../../../../utils/rest-args-error.js"
 import TableData from "../../../table-data/index.js"
 
 export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable extends AlterTableBase {
+  /**
+   * @param {object} args
+   * @param {import("../../base.js").default} args.driver
+   * @param {import("../../../table-data/index.js").default} args.tableData
+   */
   constructor({driver, tableData, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -17,9 +22,15 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     this.tableData = tableData
   }
 
-  async toSqls() {
-    const {tableData} = digs(this, "tableData")
+  /**
+   * @returns {string[]}
+   */
+  async toSQLs() {
+    const {tableData} = this
     const table = await this.getDriver().getTableByName(tableData.getName())
+
+    if (!table) throw new Error(`Table ${tableData.getName()} does not exist`)
+
     const currentTableData = await table.getTableData()
     const options = this.getOptions()
     const tableName = tableData.getName()
@@ -43,19 +54,13 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
       const newTableDataColumn = tableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
 
       if (newTableDataColumn) {
-        const settingsToClone = ["autoIncrement", "default", "index", "foreignKey", "maxLength", "primaryKey", "type"]
-
-        for (const settingToClone of settingsToClone) {
-          const camelizedSettingToClone = inflection.camelize(settingToClone)
-
-          if (!newTableDataColumn[`get${camelizedSettingToClone}`]) {
-            throw new Error(`No such method on column: get${camelizedSettingToClone}`)
-          }
-
-          if (!newTableDataColumn[`get${camelizedSettingToClone}`]()) {
-            newTableDataColumn[`set${camelizedSettingToClone}`](tableDataColumn[`get${camelizedSettingToClone}`]())
-          }
-        }
+        newTableDataColumn.setAutoIncrement(tableDataColumn.getAutoIncrement())
+        newTableDataColumn.setDefault(tableDataColumn.getDefault())
+        newTableDataColumn.setIndex(tableDataColumn.getIndex())
+        newTableDataColumn.setForeignKey(tableDataColumn.getForeignKey())
+        newTableDataColumn.setMaxLength(tableDataColumn.getMaxLength())
+        newTableDataColumn.setPrimaryKey(tableDataColumn.getPrimaryKey())
+        newTableDataColumn.setType(tableDataColumn.getType())
       }
 
       newTableData.addColumn(newTableDataColumn || tableDataColumn)
@@ -105,7 +110,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
 
     const createNewTableSQL = this.getDriver().createTableSql(newTableData)
     const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
-    const dropTableSQL = `DROP TABLE ${options.quoteTableName(tableName)}`
+    const dropTableSQLs = `DROP TABLE ${options.quoteTableName(tableName)}`
     const renameTableSQL = `ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(tableName)}`
     const sqls = []
 
@@ -114,7 +119,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     }
 
     sqls.push(insertSQL)
-    sqls.push(dropTableSQL)
+    sqls.push(dropTableSQLs)
     sqls.push(renameTableSQL)
 
     for (const tableDataIndex of currentTableData.getIndexes()) {
@@ -136,7 +141,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
         tableName,
         unique: actualTableIndex.getUnique()
       }
-      const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSqls()
+      const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
 
       for (const createIndexSQL of createIndexSQLs) {
         sqls.push(createIndexSQL)

package/src/database/drivers/sqlite/sql/create-index.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import CreateIndexBase from "../../../query/create-index-base.js"
 
 export default class VelociousDatabaseConnectionDriversSqliteSqlCreateIndex extends CreateIndexBase {

package/src/database/drivers/sqlite/sql/create-table.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import CreateTableBase from "../../../query/create-table-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {

package/src/database/drivers/sqlite/sql/delete.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import DeleteBase from "../../../query/delete-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends DeleteBase {
@@ -17,8 +19,8 @@ export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends De
         sql += this.getOptions().quote(this.conditions[columnName])
         count++
       }
-
-      return sql
     }
+
+    return sql
   }
 }

package/src/database/drivers/sqlite/sql/drop-table.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import DropTableBase from "../../../query/drop-table-base.js"
 
 export default class VelociousDatabaseConnectionDriversSqliteSqlDropTable extends DropTableBase {

package/src/database/drivers/sqlite/sql/insert.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import InsertBase from "../../../query/insert-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlInsert extends InsertBase {

package/src/database/drivers/sqlite/sql/update.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import UpdateBase from "../../../query/update-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends UpdateBase {

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

@@ -1,15 +1,23 @@
+// @ts-check
+
 import BaseTable from "../base-table.js"
 import Column from "./column.js"
 import ColumnsIndex from "./columns-index.js"
 import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversSqliteTable extends BaseTable {
+  /**
+   * @param {object} args
+   * @param {import("../base.js").default} args.driver
+   * @param {Record<string, any>} args.row
+   */
   constructor({driver, row}) {
     super()
     this.driver = driver
     this.row = row
   }
 
+  /** @returns {Promise<Array<import("../base-column.js").default>>} */
   async getColumns() {
     const result = await this.driver.query(`PRAGMA table_info('${this.getName()}')`)
     const columns = []
@@ -52,8 +60,14 @@ export default class VelociousDatabaseDriversSqliteTable extends BaseTable {
     return indexes
   }
 
+  /** @param {string} sql */
   _parseColumnsFromSQL(sql) {
     const columnsSQLMatch = sql.match(/\((.+?)\)/)
+
+    if (!columnsSQLMatch) {
+      throw new Error(`Could not match columns from SQL: ${sql}`)
+    }
+
     const columnsSQL = columnsSQLMatch[1].split(",")
     const columnNames = []
 

package/src/database/migration/index.js

@@ -90,7 +90,7 @@ export default class VelociousDatabaseMigration {
 
     tableData.addColumn(columnName, tableColumnArgs)
 
-    const sqls = await this.getDriver().alterTableSql(tableData)
+    const sqls = await this.getDriver().alterTableSQLs(tableData)
 
     for (const sql of sqls) {
       await this.getDriver().query(sql)
@@ -108,7 +108,7 @@ export default class VelociousDatabaseMigration {
 
     tableData.addColumn(columnName, tableColumnArgs)
 
-    const sqls = await this.getDriver().alterTableSql(tableData)
+    const sqls = await this.getDriver().alterTableSQLs(tableData)
 
     for (const sql of sqls) {
       await this.getDriver().query(sql)
@@ -135,9 +135,11 @@ export default class VelociousDatabaseMigration {
       },
       args
     )
-    const sql = this.getDriver().createIndexSql(createIndexArgs)
+    const sqls = this.getDriver().createIndexSQLs(createIndexArgs)
 
-    await this.getDriver().query(sql)
+    for (const sql of sqls) {
+      await this.getDriver().query(sql)
+    }
   }
 
   /**

package/src/database/pool/base-methods-forward.js

@@ -4,9 +4,9 @@
 export default function baseMethodsForward(PoolBase) {
   const forwardMethods = [
     "alterTable",
-    "alterTableSql",
+    "alterTableSQLs",
     "createIndex",
-    "createIndexSql",
+    "createIndexSQLs",
     "createTable",
     "createTableSql",
     "delete",

package/src/database/query/alter-table-base.js

@@ -22,7 +22,7 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
   /**
    * @returns {string[]}
    */
-  toSqls() {
+  toSQLs() {
     const databaseType = this.getDriver().getType()
     const sqls = []
     const {tableData} = this

package/src/database/query/base.js

@@ -40,7 +40,7 @@ export default class VelociousDatabaseQueryBase {
    * @abstract
    * @returns {string[]}
    */
-  toSqls() {
-    throw new Error("'toSqls' wasn't implemented")
+  toSQLs() {
+    throw new Error("'toSQLs' wasn't implemented")
   }
 }

package/src/database/query/create-database-base.js

@@ -1,13 +1,17 @@
 // @ts-check
 
+/**
+ * @typedef {object} CreateDatabaseArgsType
+ * @property {import("../drivers/base.js").default} driver
+ * @property {string} databaseName
+ * @property {boolean} [ifNotExists]
+ */
+
 import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
   /**
-   * @param {object} args
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {string} args.databaseName
-   * @param {boolean} [args.ifNotExists]
+   * @param {CreateDatabaseArgsType} args
    */
   constructor({driver, databaseName, ifNotExists}) {
     super({driver})

package/src/database/query/create-index-base.js

@@ -28,13 +28,15 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   generateIndexName() {
     const databaseType = this.getDriver().getType()
     let indexName = `index_on_`
+    let columnCount = 0
 
     if (databaseType == "sqlite") indexName += `${this.tableName}_`
 
-    for (const columnIndex in this.columns) {
-      if (typeof columnIndex == "number" && columnIndex > 0) indexName += "_and_"
+    for (const column of this.columns) {
+      columnCount++
+
+      if (columnCount > 1) indexName += "_and_"
 
-      const column = this.columns[columnIndex]
       let columnName
 
       if (typeof column == "string") {
@@ -52,7 +54,7 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   /**
    * @returns {string[]}
    */
-  toSqls() {
+  toSQLs() {
     const databaseType = this.getDriver().getType()
     const indexName = this.name || this.generateIndexName()
     const options = this.getOptions()
@@ -83,10 +85,13 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
     sql += ` ${options.quoteIndexName(indexName)}`
     sql += ` ON ${options.quoteTableName(tableName)} (`
 
-    for (const columnIndex in this.columns) {
-      if (typeof columnIndex == "number" && columnIndex > 0) sql += ", "
+    let columnCount = 0
+
+    for (const column of this.columns) {
+      columnCount++
+
+      if (columnCount > 1) sql += ", "
 
-      const column = this.columns[columnIndex]
       let columnName
 
       if (typeof column == "string") {

package/src/database/query/create-table-base.js

@@ -10,8 +10,8 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
   /**
    * @param {object} args
    * @param {import("../drivers/base.js").default} args.driver
-   * @param {boolean} args.ifNotExists
-   * @param {boolean} args.indexInCreateTable
+   * @param {boolean} [args.ifNotExists]
+   * @param {boolean} [args.indexInCreateTable]
    * @param {TableData} args.tableData
    */
   constructor({driver, ifNotExists, indexInCreateTable = true, tableData}) {
@@ -128,7 +128,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique: index.getUnique()
         }
-        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSqls()
+        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
 
         for (const createIndexSQL of createIndexSQLs) {
           sqls.push(createIndexSQL)
@@ -156,7 +156,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique
         }
-        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSqls()
+        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
 
         for (const createIndexSQL of createIndexSQLs) {
           sqls.push(createIndexSQL)

package/src/database/query/drop-table-base.js

@@ -1,18 +1,18 @@
-import {digs} from "diggerize"
+// @ts-check
+
 import QueryBase from "./base.js"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
   /**
    * @param {object} args
-   * @param {boolean} args.cascade
+   * @param {boolean} [args.cascade]
    * @param {import("./../drivers/base.js").default} args.driver
-   * @param {boolean} args.ifExists
-   * @param {object} args.options
+   * @param {boolean} [args.ifExists]
    * @param {string} args.tableName
    */
-  constructor({cascade, driver, ifExists, options, tableName, ...restArgs}) {
-    super({driver, options})
+  constructor({cascade, driver, ifExists, tableName, ...restArgs}) {
+    super({driver})
 
     restArgsError(restArgs)
 
@@ -24,10 +24,10 @@ export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
   /**
    * @returns {string[]}
    */
-  toSql() {
+  toSQLs() {
     const databaseType = this.getDatabaseType()
     const options = this.getOptions()
-    const {cascade, ifExists, tableName} = digs(this, "cascade", "ifExists", "tableName")
+    const {cascade, ifExists, tableName} = this
     const sqls = []
     let sql = ""
 

package/src/database/query/insert-base.js

@@ -1,6 +1,18 @@
+// @ts-check
+
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryInsertBase {
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} [args.data]
+   * @param {import("../drivers/base.js").default} args.driver
+   * @param {string} args.tableName
+   * @param {Array<string>} [args.columns]
+   * @param {boolean} [args.multiple]
+   * @param {string[]} [args.returnLastInsertedColumnNames]
+   * @param {Array<Array<string>>} [args.rows]
+   */
   constructor({columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs}) {
     if (!driver) throw new Error("No driver given to insert base")
     if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
@@ -47,7 +59,7 @@ export default class VelociousDatabaseQueryInsertBase {
           lastInsertedSQL += ` INSERTED.${driver.quoteColumn(columnName)}`
         }
 
-        if (Object.keys(this.data).length <= 0) {
+        if (this.data && Object.keys(this.data).length <= 0) {
           sql += lastInsertedSQL
         }
       } else if (driver.getType() == "mysql" || driver.getType() == "pgsql" || (driver.getType() == "sqlite" && driver.supportsInsertIntoReturning())) {
@@ -86,7 +98,7 @@ export default class VelociousDatabaseQueryInsertBase {
       sql += ")"
     }
 
-    if (this.returnLastInsertedColumnNames && driver.getType() == "mssql" && Object.keys(this.data).length > 0) {
+    if (this.returnLastInsertedColumnNames && driver.getType() == "mssql" && this.data && Object.keys(this.data).length > 0) {
       sql += lastInsertedSQL
     }
 
@@ -104,7 +116,7 @@ export default class VelociousDatabaseQueryInsertBase {
         sql += this._valuesSql(row)
       }
     } else {
-      if (Object.keys(this.data).length > 0) {
+      if (this.data && Object.keys(this.data).length > 0) {
         sql += " VALUES "
         sql += this._valuesSql(Object.values(this.data))
       } else if (driver.getType() == "sqlite" || driver.getType() == "mssql") {
@@ -123,6 +135,9 @@ export default class VelociousDatabaseQueryInsertBase {
     return sql
   }
 
+  /**
+   * @param {any[]} data
+   */
   _valuesSql(data) {
     let count = 0
     let sql = "("

package/src/database/query-parser/base-query-parser.js

@@ -11,10 +11,10 @@ import WhereParser from "./where-parser.js"
 export default class VelociousDatabaseBaseQueryParser {
   /**
    * @param {object} args
-   * @param {boolean} args.pretty
+   * @param {boolean} [args.pretty]
    * @param {import("../query/index.js").default} args.query
    */
-  constructor({pretty, query}) {
+  constructor({pretty = false, query}) {
     if (!query) throw new Error("No query given")
 
     this.pretty = pretty

package/src/database/record/index.js

@@ -468,9 +468,6 @@ class VelociousDatabaseRecord {
     const columnNameToAttributeName = this.getColumnNameToAttributeNameMap()
     const attributeNameToColumnName = this.getAttributeNameToColumnNameMap()
 
-    /** @type {Record<string, (this: VelociousDatabaseRecord) => unknown>} */
-    const proto = /** @type {any} */ (this.prototype);
-
     for (const column of this._columns) {
       this._columnsAsHash[column.getName()] = column
 
@@ -480,17 +477,18 @@ class VelociousDatabaseRecord {
       attributeNameToColumnName[camelizedColumnName] = column.getName()
       columnNameToAttributeName[column.getName()] = camelizedColumnName
 
-      proto[camelizedColumnName] = function() {
+      // @ts-expect-error
+      this.prototype[camelizedColumnName] = function() {
         return this.readAttribute(camelizedColumnName)
       }
 
       // @ts-expect-error
-      proto[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
-        // @ts-expect-error
+      this.prototype[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
         return this._setColumnAttribute(camelizedColumnName, newValue)
       }
 
-      proto[`has${camelizedColumnNameBigFirst}`] = function() {
+      // @ts-expect-error
+      this.prototype[`has${camelizedColumnNameBigFirst}`] = function() {
         // @ts-expect-error
         let value = this[camelizedColumnName]()
 
@@ -539,24 +537,20 @@ class VelociousDatabaseRecord {
         const nameCamelized = inflection.camelize(name)
         const setterMethodName = `set${nameCamelized}`
 
-        /** @type {Record<string, unknown>} */
         // @ts-expect-error
-        const self = this
-
-        /** @type {Record<string, (this: VelociousDatabaseRecord) => unknown>} */
-        const proto = /** @type {any} */ (this.prototype);
-
-        proto[name] = function getTranslatedAttribute() {
+        this.prototype[name] = function getTranslatedAttribute() {
           const locale = this._getConfiguration().getLocale()
 
           return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
-        proto[`has${nameCamelized}`] = function hasTranslatedAttribute() {
-          const candidate = self[name]
+        // @ts-expect-error
+        this.prototype[`has${nameCamelized}`] = function hasTranslatedAttribute() {
+          // @ts-expect-error
+          const candidate = this[name]
 
           if (typeof candidate == "function") {
-            const value = candidate()
+            const value = candidate.bind(this)()
 
             return this._hasAttribute(value)
           } else {
@@ -565,11 +559,9 @@ class VelociousDatabaseRecord {
         }
 
         // @ts-expect-error
-        proto[setterMethodName] = function setTranslatedAttribute(newValue) {
-          // @ts-expect-error
+        this.prototype[setterMethodName] = function setTranslatedAttribute(newValue) {
           const locale = this._getConfiguration().getLocale()
 
-          // @ts-expect-error
           return this._setTranslatedAttribute(name, locale, newValue)
         }
 
@@ -577,6 +569,7 @@ class VelociousDatabaseRecord {
           const localeCamelized = inflection.camelize(locale)
           const getterMethodNameLocalized = `${name}${localeCamelized}`
           const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
+          const hasMethodNameLocalized = `has${inflection.camelize(name)}${localeCamelized}`
 
           // @ts-expect-error
           this.prototype[getterMethodNameLocalized] = function getTranslatedAttributeWithLocale() {
@@ -587,6 +580,20 @@ class VelociousDatabaseRecord {
           this.prototype[setterMethodNameLocalized] = function setTranslatedAttributeWithLocale(newValue) {
             return this._setTranslatedAttribute(name, locale, newValue)
           }
+
+          // @ts-expect-error
+          this.prototype[hasMethodNameLocalized] = function hasTranslatedAttribute() {
+            // @ts-expect-error
+            const candidate = this[getterMethodNameLocalized]
+
+            if (typeof candidate == "function") {
+              const value = candidate.bind(this)()
+
+              return this._hasAttribute(value)
+            } else {
+              throw new Error(`Expected candidate to be a function but it was: ${typeof candidate}`)
+            }
+          }
         }
       }
     }

package/src/database/table-data/table-column.js

@@ -97,7 +97,7 @@ export default class TableColumn {
   getForeignKey() { return this.args?.foreignKey }
 
   /**
-   * @param {boolean | object} newForeignKey
+   * @param {boolean | object | undefined} newForeignKey
    * @returns {void}
    */
   setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
@@ -138,7 +138,7 @@ export default class TableColumn {
   getMaxLength() { return this.args?.maxLength }
 
   /**
-   * @param {number} newMaxLength
+   * @param {number | undefined} newMaxLength
    * @returns {void}
    */
   setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
@@ -171,7 +171,7 @@ export default class TableColumn {
   getType() { return this.args?.type }
 
   /**
-   * @param {string} newType
+   * @param {string | undefined} newType
    * @returns {void}
    */
   setType(newType) { this.args.type = newType }

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

@@ -98,6 +98,16 @@ export default class DbGenerateModel extends BaseCommand {
           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)}`
 
@@ -109,7 +119,16 @@ export default class DbGenerateModel extends BaseCommand {
             }
 
             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++
           }
         }