velocious 1.0.449 → 1.0.450

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

@@ -45,15 +45,15 @@ export default class DbGenerateFrontendModels extends BaseCommand {
 
     /**
      * Ensured directories.
-      @type {Set<string>} */
+     * @type {Set<string>} */
     const ensuredDirectories = new Set()
     /**
      * Generated model names by directory.
-      @type {Map<string, Set<string>>} */
+     * @type {Map<string, Set<string>>} */
     const generatedModelNamesByDirectory = new Map()
     /**
      * Generated files by directory.
-      @type {Map<string, Array<{className: string, fileName: string}>>} */
+     * @type {Map<string, Array<{className: string, fileName: string}>>} */
     const generatedFilesByDirectory = new Map()
 
     for (const backendProject of backendProjects) {
@@ -192,7 +192,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
   availableFrontendModelClassNames(resources) {
     /**
      * Class names.
-      @type {Set<string>} */
+     * @type {Set<string>} */
     const classNames = new Set()
 
     for (const resourceModelName in resources) {
@@ -311,8 +311,8 @@ export default class DbGenerateFrontendModels extends BaseCommand {
       }
       fileContent += " */\n"
     }
-    fileContent += this.writeAttributesTypedef({attributes, attributesTypeName, nestedWriteTypes, permittedParams: permittedCreateParams, typeName: createAttributesTypeName})
-    fileContent += this.writeAttributesTypedef({attributes, attributesTypeName, nestedWriteTypes, permittedParams: permittedUpdateParams, typeName: updateAttributesTypeName})
+    fileContent += this.writeAttributesTypedef({attributes, attributesTypeName, modelClass, nestedWriteTypes, permittedParams: permittedCreateParams, typeName: createAttributesTypeName})
+    fileContent += this.writeAttributesTypedef({attributes, attributesTypeName, modelClass, nestedWriteTypes, permittedParams: permittedUpdateParams, typeName: updateAttributesTypeName})
     fileContent += "/**\n"
     fileContent += ` * Frontend model for ${className}.\n`
     fileContent += ` * @augments {FrontendModelBase<${attributesTypeName}, ${createAttributesTypeName}, ${updateAttributesTypeName}>}\n`
@@ -553,7 +553,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     fileContent += "\n"
     fileContent += `export {${className}}\n`
     fileContent += "\n"
-    fileContent += `export default /** @type {import(${JSON.stringify(importPath)}).FrontendModelClass<${className}, ${attributesTypeName}, ${createAttributesTypeName}>} */ (${className})\n`
+    fileContent += `export default ${className}\n`
 
     return fileContent
   }
@@ -595,41 +595,78 @@ export default class DbGenerateFrontendModels extends BaseCommand {
    * @param {object} args - Arguments.
    * @param {Array<{jsDocType: string, name: string}>} args.attributes - Generated read attributes.
    * @param {string} args.attributesTypeName - Generated read attributes typedef name.
+   * @param {typeof import("../../../../../database/record/index.js").default | undefined} args.modelClass - Backend model class.
    * @param {Array<{attributes: Array<{name: string, type: string}>, relationshipName: string, typeName: string}>} args.nestedWriteTypes - Nested write typedefs.
    * @param {Array<string | Record<string, object>>} args.permittedParams - Resource permitted params spec.
    * @param {string} args.typeName - Typedef name.
    * @returns {string} - Generated typedef source.
    */
-  writeAttributesTypedef({attributes, attributesTypeName, nestedWriteTypes, permittedParams, typeName}) {
-    let output = "/**\n"
+  writeAttributesTypedef({attributes, attributesTypeName, modelClass, nestedWriteTypes, permittedParams, typeName}) {
+    const attributeLines = []
 
-    output += ` * Attributes accepted by ${typeName}.\n`
-    output += ` * @typedef {object} ${typeName}\n`
+    let output = "/**\n"
 
     const attributesByName = new Map(attributes.map((attribute) => [attribute.name, attribute]))
     const nestedWriteTypesByKey = new Map(nestedWriteTypes.map((nestedWriteType) => [`${nestedWriteType.relationshipName}Attributes`, nestedWriteType]))
+    const emittedAttributeNames = new Set()
 
     for (const entry of permittedParams) {
       if (typeof entry == "string") {
-        const attribute = attributesByName.get(entry)
+        const attributeName = this.frontendWriteAttributeName({attributeName: entry, attributesByName, modelClass})
+
+        if (emittedAttributeNames.has(attributeName)) continue
+
+        emittedAttributeNames.add(attributeName)
+
+        const attribute = attributesByName.get(attributeName)
         const type = attribute ? `${attributesTypeName}[${JSON.stringify(attribute.name)}]` : "FrontendModelAttributeValue"
 
-        output += ` * @property {${type}} [${entry}] - Permitted ${entry} value.\n`
+        attributeLines.push(` * @property {${type}} [${attributeName}] - Permitted ${attributeName} value.\n`)
       } else if (entry && typeof entry == "object" && !Array.isArray(entry)) {
         for (const key of Object.keys(entry)) {
           const nestedWriteType = nestedWriteTypesByKey.get(key)
           const type = nestedWriteType ? `Array<${nestedWriteType.typeName}>` : "Array<object>"
 
-          output += ` * @property {${type}} [${key}] - Permitted nested ${key} values.\n`
+          attributeLines.push(` * @property {${type}} [${key}] - Permitted nested ${key} values.\n`)
         }
       }
     }
 
+    output += ` * Attributes accepted by ${typeName}.\n`
+    if (attributeLines.length === 0) {
+      output += ` * @typedef {Record<string, never>} ${typeName}\n`
+    } else {
+      output += ` * @typedef {object} ${typeName}\n`
+      output += attributeLines.join("")
+    }
     output += " */\n"
 
     return output
   }
 
+  /**
+   * Resolves a permitted write attribute to the generated frontend attribute name.
+   * @param {{attributeName: string, attributesByName: Map<string, {jsDocType: string, name: string}>, modelClass: typeof import("../../../../../database/record/index.js").default | undefined}} args - Arguments.
+   * @returns {string} - Frontend attribute name used by generated accessors.
+   */
+  frontendWriteAttributeName({attributeName, attributesByName, modelClass}) {
+    if (attributesByName.has(attributeName)) return attributeName
+
+    if (modelClass) {
+      const resolvedAttributeName = modelClass.resolveAttributeName(attributeName)
+
+      if (resolvedAttributeName && attributesByName.has(resolvedAttributeName)) return resolvedAttributeName
+    }
+
+    const normalizedAttributeName = inflection.camelize(attributeName, true).toLowerCase()
+    const matchingAttributeName = Array.from(attributesByName.keys()).find((candidateName) => candidateName.toLowerCase() === normalizedAttributeName)
+
+    if (matchingAttributeName) return matchingAttributeName
+
+    // Write-only virtual params are valid permitted params even when they have no read attribute.
+    return attributeName
+  }
+
   /**
    * Runs nested write types for model.
    * @param {object} args - Arguments.
@@ -684,10 +721,11 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     if (!Array.isArray(nestedSpec)) return []
 
     return nestedSpec.filter((entry) => typeof entry == "string").map((attributeName) => {
-      const attributeConfig = this.frontendAttributeConfigForModelAttribute({attributeName, modelClass: targetModelClass})
+      const resolvedAttributeName = targetModelClass?.resolveAttributeName(attributeName) || attributeName
+      const attributeConfig = this.frontendAttributeConfigForModelAttribute({attributeName: resolvedAttributeName, modelClass: targetModelClass})
 
       return {
-        name: attributeName,
+        name: resolvedAttributeName,
         type: attributeConfig ? this.jsDocTypeForFrontendAttribute({attributeConfig}) : "FrontendModelAttributeValue"
       }
     })
@@ -776,7 +814,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
 
     /**
      * Relationship names.
-      @type {string[]} */
+     * @type {string[]} */
     const relationshipNames = []
 
     for (const entry of spec) {

package/src/environment-handlers/node.js

@@ -35,7 +35,7 @@ import toImportSpecifier from "../utils/to-import-specifier.js"
 
 /**
  * Defines this typedef.
-  @typedef {{ability?: import("../authorization/ability.js").default, offsetMinutes: number, requestTiming?: import("../http-server/client/request-timing.js").default, tenant?: ?}} TimezoneStore */
+ * @typedef {{ability?: import("../authorization/ability.js").default, offsetMinutes: number, requestTiming?: import("../http-server/client/request-timing.js").default, tenant?: ?}} TimezoneStore */
 
 /**
  * Runs path within allowed prefixes.
@@ -61,12 +61,12 @@ function pathWithinAllowedPrefixes(filePath, allowedPathPrefixes) {
 export default class VelociousEnvironmentHandlerNode extends Base{
   /**
    * Timezone async local storage.
-    @type {import("node:async_hooks").AsyncLocalStorage<TimezoneStore> | undefined} */
+   * @type {import("node:async_hooks").AsyncLocalStorage<TimezoneStore> | undefined} */
   _timezoneAsyncLocalStorage = NodeAsyncLocalStorage ? new NodeAsyncLocalStorage() : undefined
 
   /**
    * Find commands result.
-    @type {import("./base.js").CommandFileObjectType[] | undefined} */
+   * @type {import("./base.js").CommandFileObjectType[] | undefined} */
   _findCommandsResult = undefined
 
   /**
@@ -113,7 +113,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
 
       /**
        * Discovered.
-        @type {Record<string, ?>} */
+       * @type {Record<string, ?>} */
       const discovered = {}
 
       for (const file of files) {
@@ -131,7 +131,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
           .split("-")
           .map((/**
                  * Narrows the runtime value to the documented type.
-                  @type {string} */ part) => part.charAt(0).toUpperCase() + part.slice(1))
+                 * @type {string} */ part) => part.charAt(0).toUpperCase() + part.slice(1))
           .join("")
 
         discovered[modelName] = ResourceClass
@@ -863,7 +863,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
   async _structureSqlByIdentifier({dbs}) {
     const sqlByIdentifier = /**
                              * Narrows the runtime value to the documented type.
-                              @type {Record<string, string>} */ ({})
+                             * @type {Record<string, string>} */ ({})
 
     for (const identifier of Object.keys(dbs)) {
       const db = dbs[identifier]