velocious 1.0.473 → 1.0.475

package/build/frontend-model-controller.js

@@ -5,7 +5,8 @@ import Controller from "./controller.js"
 import FrontendModelBaseResource from "./frontend-model-resource/base-resource.js"
 import Response from "./http-server/client/response.js"
 import {frontendModelResourcesWithBuiltInsForBackendProject} from "./frontend-models/built-in-resources.js"
-import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcePath, frontendModelResourcesForBackendProject} from "./frontend-models/resource-definition.js"
+import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcePath, frontendModelResourcesForBackendProject, frontendModelSyncManifestForBackendProjects} from "./frontend-models/resource-definition.js"
+import {createOfflineGrantFromBootstrap} from "./sync/offline-grant.js"
 import {FrontendModelQueryError, normalizeGroup as normalizeQueryGroup, normalizeJoins as normalizeQueryJoins, normalizePluck as normalizeQueryPluck, normalizePreload as normalizeQueryPreload, normalizeSearchOperator as normalizeQuerySearchOperator, normalizeSort as normalizeQuerySort} from "./frontend-models/query.js"
 import {assignSafeProperty, deserializeFrontendModelTransportValue, isBackendModelInstance, serializeFrontendModelTransportValue} from "./frontend-models/transport-serialization.js"
 import {requestDetails} from "./error-reporting/request-details.js"
@@ -25,7 +26,11 @@ import {RansackQueryError, normalizeRansackGroup, parseRansackSort} from "./util
 function normalizeFrontendModelPreload(preload) {
   if (!preload) return null
 
-  return normalizeQueryPreload(preload)
+  try {
+    return normalizeQueryPreload(preload)
+  } catch (error) {
+    throwFrontendModelQueryErrorForParserError(error)
+  }
 }
 
 /**
@@ -863,13 +868,31 @@ export default class FrontendModelController extends Controller {
     for (const [relationshipName, relationshipPreload] of Object.entries(preload)) {
       if (relationshipPreload === false) continue
 
-      const relationship = modelClass.getRelationshipByName(relationshipName)
+      const relationship = modelClass.getRelationshipsMap()[relationshipName]
+      if (!relationship) {
+        throw frontendModelQueryError(`Unknown preload relationship "${relationshipName}" for ${modelClass.name}`)
+      }
+
       const targetModelClass = await this.ensureFrontendModelRelationshipTargetClassInitialized({
         backendProject,
         relationship
       })
 
-      if (!targetModelClass || !isPlainObject(relationshipPreload)) continue
+      if (!targetModelClass) {
+        if (isPlainObject(relationshipPreload) && Object.keys(relationshipPreload).length > 0) {
+          let message = `Cannot preload nested relationships through relationship "${relationshipName}" for ${modelClass.name} because its target model class could not be resolved`
+
+          if (relationship.getPolymorphic() && relationship.getType() === "belongsTo") {
+            message = `Cannot preload nested relationships through polymorphic relationship "${relationshipName}" for ${modelClass.name}`
+          }
+
+          throw frontendModelQueryError(message)
+        }
+
+        continue
+      }
+
+      if (!isPlainObject(relationshipPreload)) continue
 
       await this.ensureFrontendModelPreloadClassesInitialized({
         backendProject,
@@ -2430,7 +2453,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) {
@@ -2667,10 +2690,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
     }
 
     /**
@@ -2700,10 +2723,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
@@ -2722,7 +2745,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) {
@@ -3438,6 +3461,106 @@ export default class FrontendModelController extends Controller {
     return {status: "success"}
   }
 
+  /**
+   * Runs frontend sync bootstrap.
+   * @returns {Promise<void>} - Sync bootstrap response with manifest and signed offline grant.
+   */
+  async frontendSyncBootstrap() {
+    if (this.request().httpMethod() === "OPTIONS") {
+      await this.render({status: 204, json: {}})
+      return
+    }
+
+    const params = /** @type {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue | undefined>} */ (deserializeFrontendModelTransportValue(this.params()))
+    const configuration = this.getConfiguration()
+    const syncManifest = frontendModelSyncManifestForBackendProjects(configuration.getBackendProjects())
+    const offlineGrant = await createOfflineGrantFromBootstrap({
+      deviceId: this.frontendSyncBootstrapDeviceId(params),
+      grantId: this.frontendSyncBootstrapGrantId(params),
+      grantTtlMs: configuration.getSyncConfiguration().offlineGrantTtlMs,
+      now: this.frontendSyncBootstrapNow(params),
+      resources: syncManifest,
+      scopes: this.frontendSyncBootstrapScopes(params),
+      signingKey: configuration.currentOfflineGrantSigningKey(),
+      userId: this.frontendSyncBootstrapUserId()
+    })
+
+    await this.render({
+      json: /** @type {Record<string, ?>} */ (serializeFrontendModelTransportValue({
+        offlineGrant,
+        status: "success",
+        syncManifest
+      }, this.transportSerializationOptions()))
+    })
+  }
+
+  /**
+   * Resolves device id for sync bootstrap.
+   * @param {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue | undefined>} params - Request params.
+   * @returns {string} - Device id.
+   */
+  frontendSyncBootstrapDeviceId(params) {
+    if (typeof params.deviceId === "string" && params.deviceId.length > 0) return params.deviceId
+
+    throw new Error("Expected sync bootstrap deviceId")
+  }
+
+  /**
+   * Resolves grant id for sync bootstrap.
+   * @param {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue | undefined>} params - Request params.
+   * @returns {string | undefined} - Deterministic grant id for tests, generated id otherwise.
+   */
+  frontendSyncBootstrapGrantId(params) {
+    if (this.getConfiguration().getEnvironment() === "test" && typeof params.grantId === "string") return params.grantId
+
+    return undefined
+  }
+
+  /**
+   * Resolves bootstrap issue time.
+   * @param {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue | undefined>} params - Request params.
+   * @returns {Date} - Issue time.
+   */
+  frontendSyncBootstrapNow(params) {
+    if (this.getConfiguration().getEnvironment() === "test" && typeof params.now === "string") return new Date(params.now)
+
+    return new Date()
+  }
+
+  /**
+   * Resolves sync bootstrap scopes.
+   * @param {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue | undefined>} params - Request params.
+   * @returns {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue>} - Grant scopes.
+   */
+  frontendSyncBootstrapScopes(params) {
+    const scopes = params.scopes
+
+    if (scopes && typeof scopes === "object" && !Array.isArray(scopes)) {
+      return /** @type {Record<string, import("./configuration-types.js").FrontendModelSyncJsonValue>} */ (scopes)
+    }
+
+    return {}
+  }
+
+  /**
+   * Resolves current user id for sync bootstrap.
+   * @returns {string} - User id.
+   */
+  frontendSyncBootstrapUserId() {
+    const ability = this.currentAbility()
+    const currentUser = ability?.currentUser()
+
+    if (typeof currentUser === "string" || typeof currentUser === "number") return String(currentUser)
+    if (currentUser && typeof currentUser === "object") {
+      const userRecord = /** @type {{id?: string | number | (() => string | number)}} */ (currentUser)
+      const idValue = typeof userRecord.id === "function" ? userRecord.id() : userRecord.id
+
+      if (typeof idValue === "string" || typeof idValue === "number") return String(idValue)
+    }
+
+    throw new Error("Expected sync bootstrap current user")
+  }
+
   /**
    * Runs frontend api.
    * @returns {Promise<void>} - Shared frontend model API action with batch support.
@@ -3770,10 +3893,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}'.`)
     }
 
@@ -3783,7 +3906,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"}
@@ -3792,7 +3915,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
       )
     )