velocious 1.0.472 → 1.0.474

package/build/authorization/base-resource.js

@@ -115,6 +115,105 @@ export default class AuthorizationBaseResource {
     return this.context.currentUser
   }
 
+  /**
+   * Runs current device.
+   * @returns {unknown} - Current device from context.
+   */
+  currentDevice() {
+    return this.context.currentDevice
+  }
+
+  /**
+   * Runs offline grant.
+   * @returns {unknown} - Offline grant from context.
+   */
+  offlineGrant() {
+    return this.context.offlineGrant
+  }
+
+  /**
+   * Runs now.
+   * @returns {Date} - Current time from context or the system clock.
+   */
+  now() {
+    if (typeof this.context.now === "function") return this.context.now()
+    if (this.context.now instanceof Date) return this.context.now
+
+    return new Date()
+  }
+
+  /**
+   * Runs resource runtime.
+   * @returns {"backend" | "frontend" | "offline"} - Resource runtime context.
+   */
+  resourceRuntime() {
+    if (this.context.resourceRuntime === "frontend") return "frontend"
+    if (this.context.resourceRuntime === "offline") return "offline"
+
+    return "backend"
+  }
+
+  /**
+   * Runs is backend.
+   * @returns {boolean} - Whether the resource is running in the backend runtime.
+   */
+  isBackend() {
+    return this.resourceRuntime() === "backend"
+  }
+
+  /**
+   * Runs is frontend.
+   * @returns {boolean} - Whether the resource is running in the frontend runtime.
+   */
+  isFrontend() {
+    return this.resourceRuntime() === "frontend"
+  }
+
+  /**
+   * Runs is offline.
+   * @returns {boolean} - Whether the resource is running with offline context.
+   */
+  isOffline() {
+    return this.resourceRuntime() === "offline" || this.context.offlineGrant !== undefined
+  }
+
+  /**
+   * Resolves a model class from the portable resource context.
+   * @param {string} name - Model name.
+   * @returns {unknown} - Model class from registry.
+   */
+  model(name) {
+    const registry = this.context.modelRegistry
+
+    if (registry && typeof registry === "object") {
+      if ("model" in registry && typeof registry.model === "function") {
+        const modelClass = registry.model(name)
+
+        if (modelClass) return modelClass
+      }
+
+      if (name in registry) return /** @type {Record<string, unknown>} */ (registry)[name]
+    }
+
+    const contextModel = this.context.model
+
+    if (typeof contextModel === "function") {
+      const modelClass = contextModel(name)
+
+      if (modelClass) return modelClass
+    }
+
+    const configuration = this.context.configuration
+
+    if (configuration) {
+      const modelClasses = configuration.getModelClasses()
+
+      if (name in modelClasses) return modelClasses[name]
+    }
+
+    throw new Error(`${this.constructor.name} could not resolve model '${name}' from the resource context model registry.`)
+  }
+
   /**
    * Runs request.
    * @returns {import("../http-server/client/request.js").default | import("../http-server/client/websocket-request.js").default | undefined} - Request from context.

package/build/configuration-types.js

@@ -240,7 +240,7 @@
  */
 
 /**
- * @typedef {Record<string, unknown> & {configuration?: import("./configuration.js").default, currentUser?: unknown, params?: VelociousParams, request?: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default}} VelociousLooseObject
+ * @typedef {Record<string, unknown> & {configuration?: import("./configuration.js").default, currentDevice?: unknown, currentUser?: unknown, modelRegistry?: Record<string, unknown> | {model: (name: string) => unknown}, now?: Date | (() => Date), offlineGrant?: unknown, params?: VelociousParams, request?: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default, resourceRuntime?: "backend" | "frontend" | "offline"}} VelociousLooseObject
  */
 
 /**
@@ -309,13 +309,14 @@
 /**
  * @typedef {object} FrontendModelResourceConfiguration
  * @property {Array<string | FrontendModelAttributeConfiguration> | Record<string, FrontendModelAttributeConfiguration | import("./database/drivers/base-column.js").default | boolean>} attributes - Attributes to expose on the frontend model.
- * @property {string[]} [abilities] - Ability action list (camelCase action names). Defaults to `["read"]` for `find` and `index` when omitted.
+ * @property {string[]} [abilities] - Additional camelCase ability action names to expose for per-record `record.can(action)` reads. Base CRUD actions (`read`, `create`, `update`, `destroy`) are always included and must not be listed here.
  * @property {Record<string, FrontendModelAttachmentConfiguration>} [attachments] - Attachment helpers keyed by attachment name.
  * @property {string[]} [commands] - Legacy built-in command names (`index`, `find`, `create`, `update`, `destroy`, `attach`, `download`, `url`).
  * @property {Array<FrontendModelResourceCustomCommand>} [collectionCommands] - Custom collection commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
  * @property {Array<FrontendModelResourceCustomCommand>} [memberCommands] - Custom member commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
  * @property {string[]} [builtInCollectionCommands] - Built-in collection command names (`index`, `create`).
  * @property {string[]} [builtInMemberCommands] - Built-in member command names (`find`, `update`, `destroy`, `attach`, `download`, `url`).
+ * @property {string} [modelName] - Frontend model name override.
  * @property {string[]} [relationships] - Relationship names to expose in frontend models. Type and target model are inferred from the backend model's registered relationships.
  * @property {string} [primaryKey] - Primary key attribute name.
  * @property {FrontendModelResourceServerConfiguration} [server] - Optional legacy backend behavior overrides for built-in frontend actions.

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

@@ -1439,7 +1439,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
    */
   frontendAttributeIsTranslated({attributeName, modelClass, resourceClass}) {
     if (resourceClass) {
-      const translatedAttributes = resourceClass.translatedAttributes
+      const translatedAttributes = resourceClass.translatedAttributesConfig()
 
       if (Array.isArray(translatedAttributes) && translatedAttributes.includes(attributeName)) return true
     }

package/build/frontend-model-controller.js

@@ -638,11 +638,15 @@ export default class FrontendModelController extends Controller {
    */
   async withFrontendModelRequestContext(params, response, callback) {
     const configuration = this.getConfiguration()
-    const tenant = await configuration.resolveTenant({
-      params,
-      request: this.request(),
-      response
-    })
+    const tenant = configuration.getTenantResolver()
+      ? await configuration.ensureConnections({name: "Frontend model request tenant resolution"}, async () => {
+          return await configuration.resolveTenant({
+            params,
+            request: this.request(),
+            response
+          })
+        })
+      : undefined
 
     return await configuration.runWithTenant(tenant, async () => {
       return await configuration.ensureConnections({name: "Frontend model request"}, async () => {
@@ -2426,7 +2430,7 @@ export default class FrontendModelController extends Controller {
 
     const resource = this.frontendModelResourceInstance()
     const resourceClass = /** @type {typeof import("./frontend-model-resource/base-resource.js").default} */ (resource.constructor)
-    const translatedSet = new Set(resourceClass.translatedAttributes || [])
+    const translatedSet = new Set(resourceClass.translatedAttributesConfig() || [])
     let needsTranslations = false
 
     for (const attributeName of selectedAttributes) {
@@ -2663,10 +2667,10 @@ export default class FrontendModelController extends Controller {
      * Resource has attribute.
      * @param {string} attributeName - Attribute name.
      */
-    const resourceHasAttribute = (attributeName) => {
+    const resourceAttributeMethod = (attributeName) => {
       const methodName = resourceAttributeMethodName(attributeName)
 
-      return resourceInstance && typeof /** @type {Record<string, ?>} */ (/** @type {?} */ (resourceInstance))[methodName] === "function"
+      return resourceInstance?.resourceMethod(methodName) || null
     }
 
     /**
@@ -2696,10 +2700,10 @@ export default class FrontendModelController extends Controller {
      */
     const serializedAttributeValue = async (attributeName) => {
       // Check resource instance first (virtual/computed attributes via ${name}Attribute convention)
-      if (resourceHasAttribute(attributeName)) {
-        const methodName = resourceAttributeMethodName(attributeName)
+      const resourceAttribute = resourceAttributeMethod(attributeName)
 
-        return await /** @type {Record<string, Function>} */ (/** @type {?} */ (resourceInstance))[methodName](model)
+      if (resourceAttribute) {
+        return await resourceAttribute.method.call(resourceAttribute.resource, model)
       }
 
       // Fall back to model method
@@ -2718,7 +2722,7 @@ export default class FrontendModelController extends Controller {
      * @param {string} attributeName - Attribute name.
      */
     const attributeExists = (attributeName) => {
-      return (attributeName in modelAttributes) || (attributeName in /** @type {Record<string, ?>} */ (model)) || resourceHasAttribute(attributeName)
+      return (attributeName in modelAttributes) || (attributeName in /** @type {Record<string, ?>} */ (model)) || Boolean(resourceAttributeMethod(attributeName))
     }
 
     if (!selectedAttributes) {
@@ -3766,10 +3770,10 @@ export default class FrontendModelController extends Controller {
       return this.frontendModelErrorPayload("Expected frontend-model custom command scope.")
     }
 
-    const resource = /** @type {Record<string, ?>} */ (this.frontendModelResourceInstance())
-    const commandMethod = resource[methodName]
+    const resource = this.frontendModelResourceInstance()
+    const command = resource.resourceMethod(methodName)
 
-    if (typeof commandMethod !== "function") {
+    if (!command) {
       return this.frontendModelErrorPayload(`Missing frontend-model custom command '${methodName}'.`)
     }
 
@@ -3779,7 +3783,7 @@ export default class FrontendModelController extends Controller {
     // unchanged, so existing parameterless methods keep working. The args are untrusted
     // client input typed only by the declared contract, so methods must still validate.
     const commandArguments = this.frontendModelCustomCommandArguments(params)
-    const responsePayload = await commandMethod.call(resource, commandArguments)
+    const responsePayload = await command.method.call(command.resource, commandArguments)
 
     if (!responsePayload || typeof responsePayload !== "object") {
       return {status: "success"}
@@ -3788,7 +3792,7 @@ export default class FrontendModelController extends Controller {
     return /** @type {Record<string, ?>} */ (
       await this.autoSerializeFrontendModelsInPayload(
         responsePayload,
-        /** @type {{serialize: (model: ?, action: string) => Promise<Record<string, ?>>}} */ (resource),
+        /** @type {{serialize: (model: ?, action: string) => Promise<Record<string, ?>>}} */ (command.resource),
         methodName
       )
     )