velocious 1.0.10 → 1.0.12

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",

package/spec/database/record/translation-fallbacks-spec.js

@@ -0,0 +1,24 @@
+import Dummy from "../../dummy/index.js"
+import Task from "../../dummy/src/models/task.js"
+
+describe("Record - create", () => {
+  it("creates a new simple record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+      const project = task.buildProject({nameDe: "Test projekt"})
+
+      expect(project.name()).toEqual("Test projekt")
+      expect(project.nameEn()).toEqual(undefined)
+      expect(project.nameDe()).toEqual("Test projekt")
+
+      await task.save()
+
+      const sameTask = await Task.preload({project: {translations: true}}).find(task.id())
+      const sameProject = sameTask.project()
+
+      expect(sameProject.name()).toEqual("Test projekt")
+      expect(sameProject.nameEn()).toEqual(undefined)
+      expect(sameProject.nameDe()).toEqual("Test projekt")
+    })
+  })
+})

package/spec/dummy/src/config/configuration.example.js

@@ -32,5 +32,9 @@ export default new Configuration({
     })
   },
   locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
   locales: ["de", "en"]
 })

package/spec/dummy/src/config/configuration.peakflow.js

@@ -33,5 +33,9 @@ export default new Configuration({
     })
   },
   locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
   locales: ["de", "en"]
 })

package/src/configuration.js

@@ -8,7 +8,7 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({database, debug, directory, initializeModels, locale, locales, ...restArgs}) {
+  constructor({database, debug, directory, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!initializeModels) throw new Error("initializeModels wasn't given")
@@ -19,6 +19,7 @@ export default class VelociousConfiguration {
     this._initializeModels = initializeModels
     this._isInitialized = false
     this.locale = locale
+    this.localeFallbacks = localeFallbacks
     this.locales = locales
     this.modelClasses = {}
   }
@@ -31,7 +32,7 @@ export default class VelociousConfiguration {
     return this.databasePool
   }
 
-  getDatabasePoolType = () => {
+  getDatabasePoolType() {
     const poolTypeClass = digg(this, "database", "default", "master", "poolType")
 
     if (!poolTypeClass) {
@@ -41,7 +42,7 @@ export default class VelociousConfiguration {
     return poolTypeClass
   }
 
-  getDirectory = () => {
+  getDirectory() {
     if (!this._directory) {
       this._directory = process.cwd()
     }
@@ -49,6 +50,11 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  getLocaleFallbacks = () => this.localeFallbacks
+  setLocaleFallbacks(newLocaleFallbacks) {
+    this.localeFallbacks = newLocaleFallbacks
+  }
+
   getLocale() {
     if (typeof this.locale == "function") {
       return this.locale()

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

@@ -9,7 +9,7 @@ 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 Table from "./table.js"
 import Update from "../sqlite/sql/update.js"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {

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

@@ -0,0 +1,52 @@
+import debounce from "debounce"
+import {digg} from "diggerize"
+import fs from "fs/promises"
+import query from "./query.js"
+import sqlite3 from "sqlite3"
+import {open} from "sqlite"
+
+import Base from "./base.js"
+
+export default class VelociousDatabaseDriversSqliteNode extends Base {
+  async connect() {
+    const args = this.getArgs()
+    const databasePath = `db/${this.localStorageName()}.sqlite`
+
+    if (args.reset) {
+      await fs.unlink(databasePath)
+    }
+
+    this.connection = await open({
+      filename: databasePath,
+      driver: sqlite3.Database
+    })
+    await this.registerVersion()
+  }
+
+  localStorageName = () => `VelociousDatabaseDriversSqlite---${digg(this.getArgs(), "name")}`
+  disconnect = () => this.saveDatabase()
+  saveDatabase = async () => {
+    const localStorageContent = this.connection.export()
+    await this.betterLocaleStorage.set(this.localStorageName(), localStorageContent)
+  }
+
+  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
+
+  async close() {
+    await this.saveDatabase()
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  query = async (sql) => {
+    const result = await query(this.connection, sql)
+    const downcasedSQL = sql.toLowerCase().trim()
+
+    // Auto-save database in local storage in case we can find manipulating instructions in the SQL
+    if (downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
+      this.saveDatabaseDebounce()
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,20 @@
+export default async function query(connection, sql) {
+  const rows = []
+  let result
+
+  try {
+    result = await connection.all(sql)
+  } catch (error) {
+    let sqlInErrorMessage = `${sql}`
+
+    if (sqlInErrorMessage.length >= 4096) {
+      sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
+    }
+
+    error.message += `\n\n${sqlInErrorMessage}`
+
+    throw error
+  }
+
+  return result
+}

package/src/database/migrate-from-require-context.js

@@ -1,6 +1,6 @@
 import Configuration from "../configuration.js"
 import * as inflection from "inflection"
-import Migrator from "./migrator"
+import Migrator from "./migrator.js"
 
 export default class VelociousDatabaseMigrateFromRequireContext {
   constructor(configuration) {
@@ -13,7 +13,7 @@ export default class VelociousDatabaseMigrateFromRequireContext {
 
     const files = requireContext.keys()
       .map((file) => {
-        const match = file.match(/^\.\/(\d{14})-(.+)\.js$/)
+        const match = file.match(/(\d{14})-(.+)\.js$/)
 
         if (!match) return null
 

package/src/database/migrator.js

@@ -1,5 +1,5 @@
 import {digg} from "diggerize"
-import TableData from "./table-data/index"
+import TableData from "./table-data/index.js"
 
 export default class VelociousDatabaseMigrator {
   constructor({configuration}) {

package/src/database/query/index.js

@@ -4,6 +4,7 @@ import * as inflection from "inflection"
 import JoinPlain from "./join-plain.js"
 import OrderPlain from "./order-plain.js"
 import Preloader from "./preloader.js"
+import RecordNotFoundError from "../record/record-not-found-error.js"
 import SelectPlain from "./select-plain.js"
 import WhereHash from "./where-hash.js"
 import WherePlain from "./where-plain.js"
@@ -46,6 +47,21 @@ export default class VelociousDatabaseQuery {
 
   getOptions = () => this.driver.options()
 
+  async find(recordId) {
+    const conditions = {}
+
+    conditions[this.modelClass.primaryKey()] = recordId
+
+    const query = this.clone().where(conditions)
+    const record = await query.first()
+
+    if (!record) {
+      throw new RecordNotFoundError(`Couldn't find ${this.modelClass.name} with '${this.modelClass.primaryKey()}'=${recordId}`)
+    }
+
+    return record
+  }
+
   async findBy(conditions) {
     const newConditions = {}
 

package/src/database/record/index.js

@@ -7,7 +7,6 @@ import HasManyRelationship from "./relationships/has-many.js"
 import HasManyInstanceRelationship from "./instance-relationships/has-many.js"
 import * as inflection from "inflection"
 import Query from "../query/index.js"
-import RecordNotFoundError from "./record-not-found-error.js"
 
 export default class VelociousDatabaseRecord {
   static _relationshipExists(relationshipName) {
@@ -125,21 +124,6 @@ export default class VelociousDatabaseRecord {
     return record
   }
 
-  static async find(recordId) {
-    const conditions = {}
-
-    conditions[this.primaryKey()] = recordId
-
-    const query = this.where(conditions)
-    const record = await query.first()
-
-    if (!record) {
-      throw new RecordNotFoundError(`Couldn't find ${this.name} with '${this.primaryKey()}'=${recordId}`)
-    }
-
-    return record
-  }
-
   static _getConfiguration() {
     if (!this._configuration) {
       this._configuration = Configuration.current()
@@ -161,7 +145,7 @@ export default class VelociousDatabaseRecord {
   }
 
   static async initializeRecord({configuration}) {
-    if (!configuration) throw new Error("No configuration given")
+    if (!configuration) throw new Error(`No configuration given for ${this.name}`)
 
     this._configuration = configuration
     this._configuration.registerModelClass(this)
@@ -211,7 +195,7 @@ export default class VelociousDatabaseRecord {
         this.prototype[name] = function () {
           const locale = this._getConfiguration().getLocale()
 
-          return this._getTranslatedAttribute(name, locale)
+          return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
         this.prototype[setterMethodName] = function (newValue) {
@@ -419,6 +403,25 @@ export default class VelociousDatabaseRecord {
     }
   }
 
+  _getTranslatedAttributeWithFallback(name, locale) {
+    let localesInOrder
+    const fallbacks = this._getConfiguration().getLocaleFallbacks()
+
+    if (fallbacks && locale in fallbacks) {
+      localesInOrder = fallbacks[locale]
+    } else {
+      localesInOrder = [locale]
+    }
+
+    for (const fallbackLocale of localesInOrder) {
+      const result = this._getTranslatedAttribute(name, fallbackLocale)
+
+      if (result && result.trim() != "") {
+        return result
+      }
+    }
+  }
+
   _setTranslatedAttribute(name, locale, newValue) {
     let translation = this.translations().loaded()?.find((translation) => translation.locale() == locale)
 
@@ -454,6 +457,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery()
   }
 
+  static async find(...args) {
+    return this._newQuery().find(...args)
+  }
+
   static async findBy(...args) {
     return this._newQuery().findBy(...args)
   }

package/src/templates/configuration.js

@@ -15,5 +15,9 @@ export default new Configuration({
         database: "database"
       }
     }
+  },
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
   }
 })