velocious 1.0.435 → 1.0.436

package/src/database/record/instance-relationships/belongs-to.js

@@ -51,19 +51,36 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
 
     if (batched) return this.loaded()
 
-    const foreignKey = this.getForeignKey()
-    const foreignModelID = this.getModel().readColumn(foreignKey)
-    const TargetModelClass = this.getTargetModelClass()
+    await this._loadForeignModelOrBlank()
+    this.setDirty(false)
+    this.setPreloaded(true)
+
+    return this.loaded()
+  }
+
+  /**
+   * Loads the foreign model, or marks the relationship blank for empty keys.
+   * @returns {Promise<void>} - Resolves after the loaded value is assigned.
+   */
+  async _loadForeignModelOrBlank() {
+    const TargetModelClass = this._getTargetModelClassOrFail()
+    const foreignModelID = this._readForeignModelID()
 
-    if (!TargetModelClass) throw new Error("Can't load without a target model")
     if (foreignModelID === null || foreignModelID === undefined || foreignModelID === "") {
       this.setLoaded(undefined)
-      this.setDirty(false)
-      this.setPreloaded(true)
-
-      return this.loaded()
+    } else {
+      this.setLoaded(await this._loadForeignModel({foreignModelID, TargetModelClass}))
     }
+  }
 
+  /**
+   * Loads the related model from the foreign key value.
+   * @param {object} args - Options.
+   * @param {string | number | null | undefined} args.foreignModelID - Foreign model ID.
+   * @param {TMC} args.TargetModelClass - Target model class.
+   * @returns {Promise<InstanceType<TMC> | undefined>} - Loaded foreign model.
+   */
+  async _loadForeignModel({foreignModelID, TargetModelClass}) {
     const primaryKey = TargetModelClass.primaryKey()
     /**
      * Where args.
@@ -72,20 +89,31 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
 
     whereArgs[primaryKey] = foreignModelID
 
-    let query = TargetModelClass.where(whereArgs)
-
-    query = this.applyScope(query)
+    const query = this.applyScope(TargetModelClass.where(whereArgs))
 
     const foreignModel = await query.first()
 
-    if (foreignModel) {
-      this.setLoaded(foreignModel)
-    } else {
-      this.setLoaded(undefined)
-    }
-    this.setDirty(false)
-    this.setPreloaded(true)
+    return foreignModel || undefined
+  }
 
-    return this.loaded()
+  /**
+   * Gets the required target model class.
+   * @returns {TMC} - Target model class.
+   */
+  _getTargetModelClassOrFail() {
+    const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Can't load without a target model")
+
+    return TargetModelClass
+  }
+
+  /**
+   * Reads the current foreign key value from the parent record.
+   * @returns {string | number | null | undefined} - Foreign model ID.
+   */
+  _readForeignModelID() {
+    return this.getModel().readColumn(this.getForeignKey())
   }
+
 }

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

@@ -3,8 +3,10 @@ import fileExists from "../../../../../utils/file-exists.js"
 import fs from "fs/promises"
 import * as inflection from "inflection"
 
-/** Maps an effective column type to the JSDoc type used in generated base models.
- *  @type {Record<string, string>} */
+/**
+ * Maps an effective column type to the JSDoc type used in generated base models.
+ * @type {Record<string, string>}
+ */
 const jsDocTypeByColumnType = {
   bigint: "number",
   bit: "number",
@@ -35,6 +37,23 @@ const jsDocTypeByColumnType = {
 /** Effective column types whose generated setter additionally accepts a string. */
 const setterStringInputColumnTypes = new Set(["date", "datetime", "timestamp without time zone"])
 
+/**
+ * Generates a base-model relationship method.
+ * @param {{abstract?: boolean, body: string, name: string, param?: {name: string, type: string}, returns: string}} args - Method parts.
+ * @returns {string} - Generated method source.
+ */
+function generatedRelationshipMethod({abstract = false, body, name, param, returns}) {
+  let fileContent = "  /**\n"
+
+  if (abstract) fileContent += "   * @abstract\n"
+  if (param) fileContent += `   * @param {${param.type}} ${param.name}\n`
+  fileContent += `   * @returns {${returns}}\n`
+  fileContent += "   */\n"
+  fileContent += `  ${name}(${param ? param.name : ""}) { ${body} }\n`
+
+  return fileContent
+}
+
 export default class DbGenerateModel extends BaseCommand {
   async execute() {
     await this.getConfiguration().initializeModels()
@@ -291,7 +310,7 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += "  /**\n"
           fileContent += `   * @returns {Promise<import("${modelFilePath}").default | undefined>}\n`
           fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}OrLoad() { return /** @type {Promise<import("${modelFilePath}").default | undefined>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}")) }\n`
+          fileContent += `  ${relationship.getRelationshipName()}OrLoad() { return /** @type {Promise<import("${modelFilePath}").default | undefined>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}", {preloadTranslations: true})) }\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"
@@ -323,17 +342,19 @@ export default class DbGenerateModel extends BaseCommand {
           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<Array<import("${recordImport}").default>>}\n`
-          fileContent += "   */\n"
-          fileContent += `  load${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+          fileContent += generatedRelationshipMethod({
+            abstract: true,
+            body: "throw new Error(\"Not implemented\")",
+            name: `load${inflection.camelize(relationship.getRelationshipName())}`,
+            returns: `Promise<Array<import("${recordImport}").default>>`
+          })
 
           fileContent += "\n"
-          fileContent += "  /**\n"
-          fileContent += `   * @returns {Promise<Array<import("${recordImport}").default>>}\n`
-          fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}OrLoad() { return /** @type {Promise<Array<import("${recordImport}").default>>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}")) }\n`
+          fileContent += generatedRelationshipMethod({
+            body: `return /** @type {Promise<Array<import("${recordImport}").default>>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}"))`,
+            name: `${relationship.getRelationshipName()}OrLoad`,
+            returns: `Promise<Array<import("${recordImport}").default>>`
+          })
 
           fileContent += "\n"
           fileContent += "  /**\n"

package/src/frontend-model-resource/base-resource.js

@@ -330,18 +330,7 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
     const ModelClass = this.modelClass()
     const model = new ModelClass()
 
-    await ModelClass.transaction(async () => {
-      await this._assignWithVirtualSetters(model, filtered)
-      await model.save()
-
-      if (options.nestedAttributes) {
-        await this._applyNestedAttributes(model, options.nestedAttributes, options.controller || null, permit)
-      }
-    })
-
-    await this._preloadNestedWritableRelationships(model, permit)
-
-    return model
+    return await this._saveWithNestedAttributes({filtered, model, options, permit})
   }
 
   /**
@@ -363,9 +352,17 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
   async update(model, attributes, options = {}) {
     const permit = parsePermittedParams(this.permittedParams({action: "update", ability: this.ability, locals: this.locals, params: attributes}))
     const filtered = filterWritableFrontendModelAttributes(model, attributes, this, permit.attributes)
-    const ModelClass = this.modelClass()
 
-    await ModelClass.transaction(async () => {
+    return await this._saveWithNestedAttributes({filtered, model, options, permit})
+  }
+
+  /**
+   * Saves a model and applies nested attributes in one transaction.
+   * @param {{filtered: Record<string, ?>, model: import("../database/record/index.js").default, options: {controller?: ?, nestedAttributes?: Record<string, ?> | null}, permit: {attributes: string[], nested: Record<string, ?>}}} args - Save arguments.
+   * @returns {Promise<import("../database/record/index.js").default>} - Saved model.
+   */
+  async _saveWithNestedAttributes({filtered, model, options, permit}) {
+    await this.modelClass().transaction(async () => {
       await this._assignWithVirtualSetters(model, filtered)
       await model.save()