fusion-framework 1.2.3 → 1.2.5

package/index.js

@@ -134,7 +134,7 @@ header.fingerprint = () =>
     : {
         'X-Powered-By': 'Fusion Framework',
         'X-Framework': 'Fusion',
-        ['X-Fusion-Version']: '1.2.3',
+        ['X-Fusion-Version']: '1.2.5',
       }
 
 function isThenable(value) {
@@ -219,6 +219,128 @@ function resolveRoutePath(routePath, ApiClass) {
   return native.resolveRoutePathJs(routePath, ApiClass.name)
 }
 
+function apiActionName(methodName) {
+  if (typeof native.apiActionNameJs === 'function') {
+    return native.apiActionNameJs(methodName)
+  }
+  let stem = methodName
+  if (methodName.endsWith('Action') && methodName.length > 6) stem = methodName.slice(0, -6)
+  else if (methodName.endsWith('ACTION') && methodName.length > 6) stem = methodName.slice(0, -6)
+  return stem.toLowerCase()
+}
+
+function resolveMethodRoutePath(template, className, methodName) {
+  if (typeof native.resolveMethodRoutePathJs === 'function') {
+    return native.resolveMethodRoutePathJs(template, className, methodName)
+  }
+  return resolveRoutePath(template, { name: className }).replace(
+    /\[action\]/g,
+    apiActionName(methodName),
+  )
+}
+
+function joinRoutePaths(base, segment) {
+  const left = String(base || '').replace(/\/+$/, '')
+  const right = String(segment || '').replace(/^\/+|\/+$/g, '')
+  if (!right) return left || '/'
+  if (!left) return `/${right}`
+  return `${left}/${right}`
+}
+
+function resolveHandlerRoute(classBasePath, template, className, methodName) {
+  if (typeof native.resolveHandlerRouteJs === 'function') {
+    return native.resolveHandlerRouteJs(classBasePath, template, className, methodName)
+  }
+  const resolved = resolveMethodRoutePath(template, className, methodName)
+  if (String(template).startsWith('/')) {
+    return joinRoutePaths('', resolved.replace(/^\/+/, ''))
+  }
+  return joinRoutePaths(classBasePath, resolved)
+}
+
+function httpRoute(method, route, options = {}) {
+  // tags unset → inherit class route tags; tags: [] clears; tags: [...] overrides.
+  const tagsSet = Object.prototype.hasOwnProperty.call(options, 'tags')
+  const meta = {
+    method: String(method).toLowerCase(),
+    template: route,
+    tagsSet,
+    tags: tagsSet ? (Array.isArray(options.tags) ? options.tags : []) : null,
+    desc: options.desc ?? null,
+    title: options.title ?? null,
+    deprecated: !!options.deprecated,
+  }
+  function wrap(fn) {
+    fn.__fusionHttpRoute = meta
+    return fn
+  }
+  return wrap
+}
+
+function mergeSwagger(methodSwagger, classSwagger) {
+  return {
+    tags: methodSwagger.tagsSet ? methodSwagger.tags : classSwagger.tags,
+    description: methodSwagger.desc ?? classSwagger.description,
+    title: methodSwagger.title ?? classSwagger.title,
+    deprecated: !!(methodSwagger.deprecated || classSwagger.deprecated),
+  }
+}
+
+function httpGet(route, options = {}) {
+  return httpRoute('get', route, options)
+}
+function httpPost(route, options = {}) {
+  return httpRoute('post', route, options)
+}
+function httpPut(route, options = {}) {
+  return httpRoute('put', route, options)
+}
+function httpPatch(route, options = {}) {
+  return httpRoute('patch', route, options)
+}
+function httpDelete(route, options = {}) {
+  return httpRoute('delete', route, options)
+}
+function httpHead(route, options = {}) {
+  return httpRoute('head', route, options)
+}
+function httpOptions(route, options = {}) {
+  return httpRoute('options', route, options)
+}
+
+function collectRouteSlots(ApiClass, classBasePath, classSwagger) {
+  const slots = []
+  const custom = new Set()
+  const className = ApiClass.name
+
+  for (const key of Object.getOwnPropertyNames(ApiClass.prototype)) {
+    if (key === 'constructor' || key.startsWith('_')) continue
+    const fn = ApiClass.prototype[key]
+    if (typeof fn !== 'function' || !fn.__fusionHttpRoute) continue
+    custom.add(key)
+    const meta = fn.__fusionHttpRoute
+    slots.push({
+      path: resolveHandlerRoute(classBasePath, meta.template, className, key),
+      httpMethod: meta.method,
+      handlerMethod: key,
+      swagger: mergeSwagger(meta, classSwagger),
+    })
+  }
+
+  for (const methodName of HTTP_METHODS) {
+    if (custom.has(methodName)) continue
+    if (!definesMethod(ApiClass, methodName)) continue
+    slots.push({
+      path: classBasePath,
+      httpMethod: methodName,
+      handlerMethod: methodName,
+      swagger: classSwagger,
+    })
+  }
+
+  return slots
+}
+
 function emptyRequest() {
   return {
     method: '',
@@ -372,17 +494,21 @@ function router(routePath, options = {}) {
       )
     }
 
+    const classSwagger = {
+      tags: Array.isArray(options.tags) ? options.tags : [],
+      description: options.desc ?? null,
+      title: options.title ?? null,
+      deprecated: !!options.deprecated,
+    }
+
     registry.push({
       path: resolved,
+      classBasePath: resolved,
       ApiClass,
       middleware: routeMiddleware,
-      swagger: {
-        tags: Array.isArray(options.tags) ? options.tags : [],
-        description: options.desc ?? null,
-        title: options.title ?? null,
-        deprecated: !!options.deprecated,
-      },
+      swagger: classSwagger,
       version_prefix: v,
+      slots: collectRouteSlots(ApiClass, resolved, classSwagger),
     })
     return ApiClass
   }
@@ -612,18 +738,18 @@ function fillOpenApiPaths(openapi, versionFilter = null) {
 
   for (const item of registry) {
     if (!routeMatchesVersion(item, versionFilter)) continue
-    const { path: p, ApiClass, swagger: routeSwagger } = item
-    const pathParams = parsePathParams(p)
-    const resolvedPath = p.startsWith('/') ? p : `/${p}`
+    const { ApiClass, swagger: routeSwagger } = item
+    const slots = item.slots || []
 
-    if (!openapi.paths[resolvedPath]) openapi.paths[resolvedPath] = {}
+    for (const slot of slots) {
+      const pathParams = parsePathParams(slot.path)
+      const resolvedPath = slot.path.startsWith('/') ? slot.path : `/${slot.path}`
+      const routeSwaggerEntry = slot.swagger || routeSwagger
 
-    for (const methodName of HTTP_METHODS) {
-      if (!definesMethod(ApiClass, methodName)) continue
-
-      const methodUpper = String(methodName).toUpperCase()
-      const methodLower = String(methodName).toLowerCase()
+      if (!openapi.paths[resolvedPath]) openapi.paths[resolvedPath] = {}
 
+      const methodLower = String(slot.httpMethod).toLowerCase()
+      const methodUpper = methodLower.toUpperCase()
       const params = pathParams.map((name) => ({
         name,
         in: 'path',
@@ -632,11 +758,11 @@ function fillOpenApiPaths(openapi, versionFilter = null) {
       }))
 
       openapi.paths[resolvedPath][methodLower] = {
-        tags: routeSwagger?.tags?.length ? routeSwagger.tags : [],
-        summary: routeSwagger?.title ?? `${ApiClass.name}.${methodUpper}`,
-        description: routeSwagger?.description ?? '',
-        deprecated: !!routeSwagger?.deprecated,
-        operationId: `${ApiClass.name}_${methodLower}`,
+        tags: routeSwaggerEntry?.tags?.length ? routeSwaggerEntry.tags : [],
+        summary: routeSwaggerEntry?.title ?? `${ApiClass.name}.${slot.handlerMethod}`,
+        description: routeSwaggerEntry?.description ?? '',
+        deprecated: !!routeSwaggerEntry?.deprecated,
+        operationId: `${ApiClass.name}_${slot.handlerMethod}`,
         parameters: params,
         responses: { 200: { description: 'OK' } },
       }
@@ -691,7 +817,12 @@ function swaggerUiHtml(swagger, openapiUrl, primaryName = null) {
   const showUrlInput = swagger.navbar?.showUrlInput !== false
   const hideUrlCss =
     navbarEnabled && !showUrlInput
-      ? `<style>.topbar form { display: none !important; }</style>`
+      ? `<style>
+      .swagger-ui .topbar .download-url-wrapper input[type=text],
+      .swagger-ui .topbar .download-url-wrapper .download-url-button {
+        display: none !important;
+      }
+    </style>`
       : ''
   const standaloneScript = navbarEnabled
     ? `<script src="https://unpkg.com/swagger-ui-dist/swagger-ui-standalone-preset.js"></script>`
@@ -751,16 +882,16 @@ class FusionApp {
     if (this.mounted) return
     activeGlobalMiddleware = [...this._middleware]
 
-    for (const { path: routePath, ApiClass, middleware: routeMiddleware = [] } of registry) {
-      for (const methodName of HTTP_METHODS) {
-        if (!definesMethod(ApiClass, methodName)) continue
-        this.engine.route(methodName.toUpperCase(), routePath, (errOrRequest, maybeRequest) => {
+    for (const { ApiClass, middleware: routeMiddleware = [], slots = [] } of registry) {
+      for (const slot of slots) {
+        const handlerMethod = slot.handlerMethod
+        this.engine.route(String(slot.httpMethod).toUpperCase(), slot.path, (errOrRequest, maybeRequest) => {
           const request = nativeRequestArg(errOrRequest, maybeRequest)
           const chain = [...activeGlobalMiddleware, ...routeMiddleware]
           const handler = async (req) => {
             try {
               const instance = new ApiClass(req || emptyRequest())
-              const fn = instance[methodName]
+              const fn = instance[handlerMethod]
               return await Promise.resolve(fn.call(instance))
             } catch (err) {
               if (err instanceof HTTPException) return err.toResponse()
@@ -852,8 +983,17 @@ module.exports = {
   HTTPException,
   router,
   route,
+  httpGet,
+  httpPost,
+  httpPut,
+  httpPatch,
+  httpDelete,
+  httpHead,
+  httpOptions,
   apiResourceName,
   resolveRoutePath,
+  resolveHandlerRoute,
+  apiActionName,
   configure,
   getSettings,
   settings,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fusion-framework",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Class-based HTTP framework for Node.js, powered by a shared Rust core via N-API",
   "keywords": [
     "http",