rajt 0.0.77 → 0.0.79

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.77",
+  "version": "0.0.79",
   "type": "module",
   "main": "./src/index.ts",
   "bin": {

package/src/cli/commands/utils.ts

@@ -58,6 +58,14 @@ export const formatTime = (ms: number) => {
   return `${(ms / 1000).toFixed(2)}s`
 }
 
+const nodeModules = [
+  'crypto', 'buffer', 'http', 'fs', 'path', 'events', 'stream', 'util',
+  'url', 'querystring', 'os', 'child_process', 'cluster', 'dns', 'net',
+  'tls', 'https', 'zlib', 'readline', 'repl', 'vm', 'module', 'assert',
+  'timers', 'string_decoder', 'punycode', 'perf_hooks', 'dgram', 'tty',
+  'worker_threads', 'wasi'
+].flatMap(lib => ['node:'+ lib, lib])
+
 const dist = '.rajt/dist'
 export const build = async (platform: Platform) => {
   const startTime = Date.now()
@@ -99,8 +107,7 @@ export const build = async (platform: Platform) => {
       '@aws-sdk', '@smithy',
       ...(isCF ? [
         'cloudflare:workers',
-        'node:crypto', 'crypto',
-        'node:buffer', 'buffer',
+        ...nodeModules,
       ] : []),
     ],
     metafile: true,

package/src/create-app.ts

@@ -1,15 +1,12 @@
 import { Hono } from 'hono'
 import { logger } from 'hono/logger'
 import { matchedRoutes } from 'hono/route'
-import { basicAuth } from 'hono/basic-auth'
-import { openAPIRouteHandler, describeRoute, resolver } from 'hono-openapi'
-import { Scalar } from '@scalar/hono-api-reference'
+import { describeRoute } from 'hono-openapi'
 import { Envir, Datte } from 't0n'
 import type {
   Env, Context, Next,
   HTTPResponseError,
   ServerOptions,
-  DescribeRouteOptions,
 } from './types'
 import { resolve, resolveMiddleware } from './utils/resolve'
 import { getMiddlewares, getHandler } from './register'
@@ -17,7 +14,6 @@ import request, { GET_REQUEST } from './request'
 import response from './response'
 import { isDev } from './utils/environment'
 import { gray } from './utils/colors'
-import packageJson from '../../../package.json'
 
 const NFHandler = () => response.notFound()
 const EHandler = async (e: Error | HTTPResponseError) => {
@@ -65,7 +61,7 @@ const EHandler = async (e: Error | HTTPResponseError) => {
   // stack: isDev (? e.stack : undefined
 }
 
-export const createApp = <E extends Env>(options?: ServerOptions<E> & { configs: any }) => {
+export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   // const root = options?.root ?? '/'
   const app = options?.app ?? new Hono<E>()
 
@@ -121,96 +117,6 @@ export const createApp = <E extends Env>(options?: ServerOptions<E> & { configs:
     }
   }
 
-  const _docs = options?.configs?.docs ?? {}
-  const docs = {
-    ..._docs,
-    disable: !!_docs?.disable,
-    path: _docs?.path || '/docs',
-    auth: _docs?.auth || {},
-  }
-
-  if (docs.disable) return app
-
-  if (docs?.auth?.username && docs?.auth?.password) {
-    app.use(docs.path +'/*', async (c, next) => {
-      const realm = docs.auth?.realm || 'Docs'
-      const unauthorized = response.unauthorized(
-        null,
-        {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
-      )
-      if (!c.req.raw.headers.get('Authorization')) return unauthorized
-      const auth = basicAuth({ username: docs.auth.username, password: docs.auth.password, realm })
-
-      try {
-        await auth(c, next)
-      } catch {
-        return unauthorized
-      }
-    })
-  }
-
-  const appName = Envir.get('APP_NAME', packageJson?.name || 'API Docs')
-  const appVersion = Envir.get('APP_VERSION', packageJson?.version || '1.0.0')
-
-  app.get(
-    docs.path +'/openapi',
-    openAPIRouteHandler(app, {
-      documentation: {
-        info: {
-          title: appName,
-          version: appVersion,
-          description: Envir.get('APP_DESCRIPTION', packageJson?.description || ''),
-        },
-        components: {
-          securitySchemes: {
-            JWT: {
-              type: 'http',
-              scheme: 'bearer',
-              bearerFormat: 'JWT',
-            },
-          },
-          responses: {
-            500: {
-              description: 'Internal Server Error',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      m: {
-                        type: 'array',
-                        items: { type: 'string' },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-            ...docs?.responses,
-          },
-        },
-      },
-    })
-  )
-
-  app.get(
-    docs.path,
-    Scalar({
-      theme: 'saturn',
-      url: docs.path +'/openapi',
-      showDeveloperTools: 'never',
-      telemetry: false,
-      documentDownloadType: 'json', //'direct',
-      isLoading: true,
-      persistAuth: true,
-      hideClientButton: true,
-      slug: appName.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ appVersion,
-      // hideDownloadButton: true,
-      // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
-      customCss: `[href="https://www.scalar.com"]{display:none}`,
-    })
-  )
-
   return app
 }
 

package/src/dev.ts

@@ -1,9 +1,10 @@
 import { dirname, join } from 'node:path'
 import { config } from 'dotenv'
-import createApp from './create-app'
 import { getRoutes, getMiddlewares, getConfigs } from './routes'
 import { registerHandler, registerMiddleware } from './register'
 import Config from './config'
+import OAS from './oas'
+import createApp from './create-app'
 import { Ability } from 'rajt/auth'
 import { setEnv, detectEnvironment } from 'rajt/env'
 
@@ -25,6 +26,8 @@ middlewares.forEach(mw => registerMiddleware(mw.handle))
 Ability.fromRoutes(routes)
 Ability.roles = Config.get('roles', {})
 
-const app = createApp({ routes, configs: Config.get('rajt', {}) })
+// @ts-ignore
+const app = createApp({ routes })
+OAS.register(app, Config.get('rajt', {}))
 
 export default app

package/src/oas.ts

@@ -0,0 +1,110 @@
+import { STATUS_CODES } from 'node:http'
+import { basicAuth } from 'hono/basic-auth'
+import { Scalar } from '@scalar/hono-api-reference'
+import { generateSpecs, resolver } from 'hono-openapi'
+import { Envir } from 't0n'
+import z from 'zod'
+import response from './response'
+import { getHandler } from './register'
+import type { Hono } from './types'
+
+// @ts-ignore
+import packageJson from '../../../package.json'
+
+export default class OAS {
+  static #config(config: any) {
+    const docs = config?.docs ?? {}
+
+    const appName = Envir.get('APP_NAME', packageJson?.name || 'API Docs')
+    const appVersion = Envir.get('APP_VERSION', packageJson?.version || '1.0.0')
+
+    return {
+      ...docs,
+      disable: !!docs?.disable,
+      path: docs?.path || '/docs',
+      auth: docs?.auth || {},
+      agent: !docs?.agent,
+      appName, appVersion,
+    }
+  }
+
+  static register(app: Hono, config: any) {
+    const opts = this.#config(config)
+    if (opts.disable) return
+
+    if (opts?.auth?.username && opts?.auth?.password) {
+      app.use(opts.path +'/*', async (c, next) => {
+        const realm = opts.auth?.realm || 'Docs'
+        const unauthorized = response.unauthorized(
+          null,
+          {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
+        )
+        if (!c.req.raw.headers.get('Authorization')) return unauthorized
+        const auth = basicAuth({ username: opts.auth.username, password: opts.auth.password, realm })
+
+        try {
+          await auth(c, next)
+        } catch {
+          return unauthorized
+        }
+      })
+    }
+
+    app.get(opts.path + '/openapi', async () => response.json(getHandler('RAJT_OPENAPI')))
+
+    app.get(
+      opts.path,
+      Scalar({
+        theme: 'saturn',
+        url: opts.path +'/openapi',
+        showDeveloperTools: 'never',
+        telemetry: false,
+        documentDownloadType: 'json', //'direct',
+        isLoading: true,
+        persistAuth: true,
+        hideClientButton: true,
+        pageTitle: opts.appName,
+        agent: { disabled: opts.agent },
+        slug: opts.appName?.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ opts.appVersion,
+        // hideDownloadButton: true,
+        // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
+        customCss: `[href="https://www.scalar.com"]{display:none}`,
+      })
+    )
+  }
+
+  static async generateSpecs(app: Hono, config: any) {
+    const opts = this.#config(config)
+    if (opts.disable) return {}
+
+    return await generateSpecs(app, {
+      documentation: {
+        info: {
+          title: opts.appName,
+          version: opts.appVersion,
+          description: Envir.get('APP_DESCRIPTION', packageJson?.description || ''),
+        },
+        components: {
+          securitySchemes: {
+            JWT: {
+              type: 'http',
+              scheme: 'bearer',
+              bearerFormat: 'JWT',
+            },
+          },
+          responses: {
+            500: {
+              description: STATUS_CODES[500],
+              content: { // @ts-ignore
+                'application/json': await resolver(z.object({
+                  m: z.array(z.string()),
+                })).toOpenAPISchema(),
+              },
+            },
+            ...opts?.responses,
+          },
+        },
+      },
+    })
+  }
+}

package/src/prod.ts

@@ -1,4 +1,5 @@
 import Config from './config'
+import OAS from './oas'
 import { Ability } from './auth'
 import createApp from './create-app'
 
@@ -12,4 +13,7 @@ Ability.fromRoutes(routes)
 Ability.roles = Config.get('roles', {})
 
 // @ts-ignore
-export const app = createApp({ routes, configs: Config.get('rajt', {}) })
+const app = createApp({ routes })
+OAS.register(app, Config.get('rajt', {}))
+
+export { app }

package/src/routes.ts

@@ -5,12 +5,20 @@ import glob from 'tiny-glob'
 import { config } from 'dotenv'
 
 import { IMPORT } from 't0n'
+import { registerHandler, registerMiddleware } from './register'
+import createApp from './create-app'
 import { isAnonFn } from './utils/func'
 import ensureDir from './utils/ensuredir'
 import versionSHA from './utils/version-sha'
-import type { Routes } from './types'
+import type { Routes, StandardSchemaV1 } from './types'
 import { substep, warn } from './utils/log'
 
+import OAS from './oas'
+import z from 'zod'
+import { resolver } from 'hono-openapi'
+import { mimes } from 'hono/utils/mime'
+import { STATUS_CODES } from 'node:http'
+
 const __filename = new URL(import.meta.url).pathname
 const __root = resolve(dirname(__filename), '../../..')
 
@@ -43,6 +51,50 @@ const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string
   }
 }
 
+function isZodSchema(obj: any): obj is z.ZodType {
+  return (
+    obj &&
+    typeof obj == 'object' &&
+    ('_def' in obj || '_type' in obj) &&
+    (obj.safeParse !== undefined || obj.parse !== undefined)
+  )
+}
+
+function ResolveDescribeSchema(obj: any, deep: boolean = false) {
+  if (!obj || typeof obj !== 'object') return obj
+  if (isZodSchema(obj))
+    return { content: {'application/json': { schema: resolver(obj as unknown as StandardSchemaV1) }} }
+
+  if (obj.content && typeof obj.content == 'object') {
+    for (const mediaType in obj.content) {
+      const contentItem = obj.content[mediaType]
+      if (contentItem?.schema && isZodSchema(contentItem.schema))
+        contentItem.schema = resolver(contentItem.schema)
+
+      if (mediaType in mimes) {
+        obj.content[mimes[mediaType]] = contentItem
+        delete obj.content[mediaType]
+      }
+    }
+
+    return obj
+  }
+
+  for (const key in obj) {
+    if (obj[key] && typeof obj[key] == 'object') {
+      obj[key] = ResolveDescribeSchema(obj[key], true)
+
+      if (!deep && !obj[key]?.description) {
+        const desription = (new Response(null, { status: Number(key) })).statusText || STATUS_CODES[key]
+        if (desription) obj[key].description = desription
+      }
+
+    }
+  }
+
+  return obj
+}
+
 let hasDuplicatedRoutes = false
 export async function getRoutes(
   dirs: string[] = ['actions', 'features', 'routes']
@@ -70,9 +122,10 @@ export async function getRoutes(
         ...d,
         responses: {
           500: {$ref: '#/components/responses/500'},
-          ...d?.responses,
+          ...ResolveDescribeSchema(d?.responses),
         }
       }
+
       routes.push({
         method, path: uri,
         name,
@@ -261,16 +314,24 @@ export async function cacheRoutes() {
     throw new Error("The app can't build with duplicate routes")
 
   const middlewares = await getMiddlewares()
-  const configs = Object.entries(await getConfigs())
+  const configs = await getConfigs()
+
+  routes.forEach(r => registerHandler(r.name, r.handle))
+  middlewares.forEach(mw => registerMiddleware(mw.handle))
+
+  // @ts-ignore
+  const openApi = await OAS.generateSpecs(createApp({ routes }), configs?.rajt || {})
 
   const iPath = join(__root, '.rajt/import-routes.mjs')
   ensureDir(iPath)
   writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
 ${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
-${configs?.length ? `import Config from '../node_modules/rajt/src/config'\nConfig.add({${configs.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
+${Object.entries(configs)?.length ? `import Config from '../node_modules/rajt/src/config'\nConfig.add(${stringifyToJS(configs)})` : ''}
 
 import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
 
+${Object.entries(openApi)?.length ? `registerHandler('RAJT_OPENAPI', ${stringifyToJS(openApi)})` : ''}
+
 ${routes.map(r => `import ${r.name} from '../${normalizeImportPath(r.file)}'`).join('\n')}
 ${middlewares.map(r => `import ${r.name} from '../${normalizeImportPath(r.file)}'`).join('\n')}
 

package/src/types.ts

@@ -6,17 +6,19 @@ import type {
 } from 'hono'
 import type { ResponseHeader } from 'hono/utils/headers'
 // import type { StatusCode } from 'hono/utils/http-status'
-import type { BaseMime } from 'hono/utils/mime'
-import type { DescribeRouteOptions } from 'hono-openapi'
+import { mimes, type BaseMime } from 'hono/utils/mime'
+import type { OpenAPIV3_1, OpenAPIV3 } from 'openapi-types'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { DescribeRouteOptions as RawDescribeRouteOptions, ResolverReturnType } from 'hono-openapi'
 import z from 'zod'
 import Action from './action'
 import request from './request'
 import response from './response'
 import validator from './validator'
 
-
 // export type { H, Handler, HandlerResponse } from 'hono/types'
 export type {
+  Hono,
   Env, Context, Next,
   // ErrorHandler, NotFoundHandler,
   MiddlewareHandler, // TODO: remove..
@@ -29,7 +31,7 @@ export type {
   RedirectStatusCode,
   StatusCode,
 } from 'hono/utils/http-status'
-export type { BaseMime, DescribeRouteOptions }
+export type { BaseMime, StandardSchemaV1 }
 
 type PublicMethods<T> = {
   [K in keyof T]: K extends `#${string}` | `$${string}` | symbol | 'prototype' ? never : K
@@ -46,6 +48,26 @@ export type Rule = {
 }
 export type Rules = Rule[] | Rule | null
 
+export type StandardSchema = StandardSchemaV1 | OpenAPIV3_1.ReferenceObject
+export type DescribeRouteOptions = Omit<RawDescribeRouteOptions, 'responses'> & {
+  responses?: {
+    [key: string | number]: (Omit<OpenAPIV3.ResponseObject, 'description' | 'headers' | 'content' | 'links'> & {
+      description?: string,
+      headers?: { // TODO maybe dont accept ResolverReturnType
+        [header: string]: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.HeaderObject
+      },
+      content?: {
+        [key: BaseMime | keyof typeof mimes]: Omit<OpenAPIV3_1.MediaTypeObject, 'schema'> & {
+          schema?: StandardSchema | OpenAPIV3_1.SchemaObject | ResolverReturnType,
+        },
+      },
+      links?: { // TODO maybe dont accept ResolverReturnType
+        [link: string]: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.LinkObject
+      },
+    }) | StandardSchema,
+  },
+}
+
 export type Route = {
   method: string,
   path: string,

package/src/validator.ts

@@ -40,7 +40,7 @@ export default class $Validator {
     return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
       .flatMap(rule => validator(rule.target, rule.schema, (result, c) => {
         if (!result.success) // @ts-ignore
-          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
+          return response.badRequest(result.error)
       }))
   }
 }