@owlmeans/server-api 0.1.0

package/build/utils/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/utils/server.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@owlmeans/server-api",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 264 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    },
+    "./utils": {
+      "import": "./build/utils/index.js",
+      "require": "./build/utils/index.js",
+      "default": "./build/utils/index.js",
+      "module": "./build/utils/index.js",
+      "types": "./build/utils/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@fastify/cors": "^10.0.1",
+    "@fastify/helmet": "^12.0.1",
+    "@fastify/middie": "^9.0.2",
+    "@fastify/multipart": "^9.0.1",
+    "@owlmeans/api": "^0.1.0",
+    "@owlmeans/auth": "^0.1.0",
+    "@owlmeans/auth-common": "^0.1.0",
+    "@owlmeans/context": "^0.1.0",
+    "@owlmeans/error": "^0.1.0",
+    "@owlmeans/module": "^0.1.0",
+    "@owlmeans/route": "^0.1.0",
+    "@owlmeans/server-context": "^0.1.0",
+    "@owlmeans/server-module": "^0.1.0",
+    "ajv-errors": "^3.0.0",
+    "fastify": "^5.0.0",
+    "fastify-raw-body": "^5.0.0",
+    "pino-pretty": "^13.0.0"
+  },
+  "peerDependencies": {
+    "ajv": "*",
+    "ajv-formats": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.8",
+    "nodemon": "^3.1.7",
+    "npm-check": "^6.0.1",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/consts.ts

@@ -0,0 +1,7 @@
+
+export const DEFAULT_ALIAS = 'api-server'
+
+export const PORT = 80
+
+export const CLOSED_HOST = '127.0.0.1'
+export const OPENED_HOST = '0.0.0.0'

package/src/errors.ts

@@ -0,0 +1,35 @@
+
+import { ApiError } from '@owlmeans/api'
+import { ResilientError } from '@owlmeans/error'
+
+export class AuthFailedError extends ApiError {
+  public static override typeName = 'AuthFailedError'
+
+  constructor(message: string = 'error') {
+    super(`auth:${message}`)
+    this.type = AuthFailedError.typeName
+  }
+}
+
+export class AccessError extends ApiError {
+  public static override typeName = `Access${AuthFailedError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`access:${message}`)
+    this.type = AccessError.typeName
+  }
+}
+
+export class NoFileError extends ApiError {
+  public static override typeName = 'NoFileError'
+
+  constructor() {
+    super('no file')
+    this.type = NoFileError.typeName
+  }
+}
+
+ResilientError.registerErrorClass(AuthFailedError)
+ResilientError.registerErrorClass(AccessError)
+ResilientError.registerErrorClass(NoFileError)
+

package/src/helper.ts

@@ -0,0 +1,89 @@
+
+import type { BasicConfig, BasicContext } from '@owlmeans/context'
+import { assertContext } from '@owlmeans/context'
+import { ModuleOutcome } from '@owlmeans/module'
+import type { AbstractRequest, AbstractResponse } from '@owlmeans/module'
+import type { RefedModuleHandler } from '@owlmeans/server-module'
+import type { Config, Context } from './types.js'
+import type { FastifyRequest } from 'fastify'
+import type { MultipartFile } from '@fastify/multipart'
+
+const _castContextFromOriginal = <C extends BasicConfig, T extends BasicContext<C> = BasicContext<C>>(req: AbstractRequest, def: T): T => {
+  return req.original._ctx ?? def
+}
+
+export const handleBody: <T>(
+  handler: (payload: T, ctx: BasicContext<BasicConfig>, req: AbstractRequest) => Promise<any>
+) => RefedModuleHandler<AbstractResponse<any>> = handler => ref => async (req, res) => {
+  const ctx = assertContext(ref.ref?.ctx) as Context
+  try {
+    res.resolve(await handler(
+      req.body as any,
+      _castContextFromOriginal<Config, Context>(req, ctx) as BasicContext<BasicConfig>,
+      req,
+    ), ModuleOutcome.Ok)
+  } catch (e) {
+    res.reject(e as Error)
+  }
+
+  return res.value
+}
+
+export const handleParams: <T>(
+  handler: (payload: T, ctx: BasicContext<BasicConfig>, req: AbstractRequest) => Promise<any>
+  // @TODO Here and everywher it looks like AbstractResponse is messed up here instead of abstract request
+) => RefedModuleHandler<AbstractResponse<any>> = handler => ref => async (req, res) => {
+  const ctx = assertContext(ref.ref?.ctx) as Context
+  try {
+    res.resolve(await handler(
+      req.params as any,
+      _castContextFromOriginal<Config, Context>(req, ctx) as BasicContext<BasicConfig>,
+      req,
+    ), ModuleOutcome.Ok)
+  } catch (e) {
+    res.reject(e as Error)
+  }
+
+  return res.value
+}
+
+export const handleRequest: (
+  handler: (payload: AbstractRequest, ctx: BasicContext<BasicConfig>, res?: AbstractResponse<any>) => Promise<any>
+) => RefedModuleHandler<AbstractResponse<any>> = handler => ref => async (req, res) => {
+  const ctx = assertContext(ref.ref?.ctx) as Context
+  try {
+    res.resolve(await handler(
+      req, _castContextFromOriginal<Config, Context>(req, ctx) as BasicContext<BasicConfig>, res
+    ), ModuleOutcome.Ok)
+  } catch (e) {
+    res.reject(e as Error)
+  }
+
+  return res.value
+}
+
+export const handleIntermediate: (
+  handler: (payload: AbstractRequest, ctx: BasicContext<BasicConfig>) => Promise<BasicContext<BasicConfig> | null>
+) => RefedModuleHandler<AbstractResponse<Context | null>> = handler => ref => async (req, res) => {
+  const ctx = assertContext(ref.ref?.ctx) as Context
+  try {
+    const result = await handler(
+      req, _castContextFromOriginal<Config, Context>(req, ctx) as BasicContext<BasicConfig>
+    )
+    if (result != null) {
+      res.resolve(result)
+    }
+
+    return res.value
+  } catch (e) {
+    res.reject(e as Error)
+  }
+}
+
+export const extractUploadedFile = async <T extends {} = {}>(req: AbstractRequest<T>): Promise<UploadedFile | undefined> => {
+  const request = req.original as FastifyRequest
+
+  return request.file()
+}
+
+export interface UploadedFile extends MultipartFile { }

package/src/index.ts

@@ -0,0 +1,6 @@
+
+export type * from './types.js'
+export * from './server.js'
+export * from './consts.js'
+export * from './errors.js'
+export * from './helper.js'

package/src/server.ts

@@ -0,0 +1,183 @@
+import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
+import type { ApiServer, ApiServerAppend } from './types.js'
+import { Layer, assertContext, createService } from '@owlmeans/context'
+import { canServeModule, executeResponse, provideRequest } from './utils/index.js'
+import { DEFAULT_ALIAS, CLOSED_HOST, PORT, OPENED_HOST } from './consts.js'
+import type { ServerModule } from '@owlmeans/server-module'
+import { RouteMethod } from '@owlmeans/route'
+import { createServerHandler, fixFormatDates } from './utils/index.js'
+import { provideResponse } from '@owlmeans/module'
+import { TOKEN_UPDATE } from '@owlmeans/auth-common'
+
+import Fastify from 'fastify'
+import type { FastifyRequest } from 'fastify'
+import cors from '@fastify/cors'
+import rawBody from 'fastify-raw-body'
+import Middie from '@fastify/middie'
+import Helmet from '@fastify/helmet'
+import Multipart from '@fastify/multipart'
+
+import formatsPlugin from 'ajv-formats'
+import Ajv from 'ajv'
+import ajvErrors from "ajv-errors"
+
+
+const ajv = new Ajv({
+  removeAdditional: true,
+  useDefaults: true,
+  coerceTypes: true,
+  allErrors: true,
+  strict: false
+})
+formatsPlugin(ajv)
+ajvErrors(ajv, { singleError: true })
+
+type Config = ServerConfig
+type Context = ServerContext<Config>
+
+export const createApiServer = (alias: string): ApiServer => {
+  const location = `service:${alias}`
+  const _assertContext = (context: Context | undefined): Context => assertContext<Config, Context>(context, location)
+
+  const service = createService<ApiServer>(alias, {
+    server: Fastify({
+      logger: true,
+      /*{
+       transport: {
+         target: 'pino-pretty',
+         options: {
+           singleLine: true,
+           translateTime: 'HH:MM:ss Z',
+           ignore: 'pid,hostname',
+         },
+       },
+     }*/
+    }),
+
+    layers: [Layer.System],
+
+    listen: async () => {
+      const context = _assertContext(service.ctx as Context)
+
+      const config = context.cfg.services[context.cfg.service]
+
+      const port = config?.internalPort ?? config?.port ?? PORT
+      const host = config.opened === true ? OPENED_HOST : CLOSED_HOST
+      await service.server.listen({ port, host })
+      console.info(`${location}: server listening on ${host}${port != null ? `:${port}` : ''}`)
+
+      process.on('SIGTERM', () => {
+        service.server.close().then(() => {
+          process.exit(0)
+        })
+      })
+    }
+  }, service => async () => {
+    if (service.server.server.listening) {
+      await service.server.close()
+      service.server = Fastify({ logger: true })
+    }
+
+    const context = _assertContext(service.ctx as Context)
+
+    const server = service.server
+    // @TODO We should ensure some way that Resilient Error is thrown and go to the flow
+    server.setValidatorCompiler(opts => ajv.compile(opts.schema))
+    // @TODO It's quite unsafe and should be properly configured
+    await server.register(cors, {
+      origin: '*',
+      exposedHeaders: [TOKEN_UPDATE]
+    })
+
+    await server.register(Multipart, {
+      throwFileSizeLimit: true,
+      // @TODO It shouldn't be this way, becaues the file is buffer this way
+      attachFieldsToBody: 'keyValues',
+      limits: {
+        fileSize: 5 * 1024 * 1024,
+        files: 5,
+      }
+    })
+    await server.register(Helmet)
+    await server.register(rawBody, { field: 'rawBody', global: true, runFirst: true })
+    await server.register(Middie)
+
+    server.addHook('preHandler', async (request, reply) => {
+      const context = _assertContext(service.ctx as Context);
+      // We pass context further using fastify request object
+      (request as any)._ctx = await context.modules<ServerModule<FastifyRequest>>().filter(
+        module => canServeModule(context, module) && module.route.isIntermediate()
+      ).reduce<Promise<Context>>(async (promise, module) => {
+        let context = await promise
+        if (reply.sent) {
+          return context
+        }
+
+        // await module.route.resolve(context as any)
+        await module.resolve()
+        // Actually intermediate module can be created without handler by elevate function
+        if (module.route.match(request) && module.handle != null) {
+          const response = provideResponse(reply)
+          const currentRequest = provideRequest(module.alias, request, true)
+          currentRequest.original._ctx = context
+          const result: Context = await module.handle(currentRequest, response)
+          if (result != null) {
+            context = result
+          }
+          executeResponse(response, reply, true)
+        }
+        return context
+      }, Promise.resolve(context))
+    })
+
+    await Promise.all(
+      context.modules<ServerModule<FastifyRequest>>()
+        .filter(module => canServeModule(context, module) && !module.route.isIntermediate())
+        .map(async module => {
+          // await module.route.resolve(context as any)
+          await module.resolve()
+          const method = module.route.route.method ?? RouteMethod.GET
+          if (module.handle == null) {
+            return
+          }
+          server.route({
+            url: module.getPath(), method,
+            schema: {
+              consumes: [
+                'application/json',
+                'application/x-www-form-urlencoded',
+                'multipart/form-data',
+              ],
+              querystring: fixFormatDates(module.filter?.query ?? {}),
+              ...(method !== RouteMethod.GET ? { body: fixFormatDates(module.filter?.body ?? {}) } : {}),
+              params: fixFormatDates(module.filter?.params ?? {}),
+              response: module.filter?.response,
+              headers: fixFormatDates(module.filter?.headers ?? {})
+            },
+            handler: createServerHandler(module, location)
+          })
+        })
+    )
+
+    service.initialized = true
+  })
+
+  return service
+}
+
+export const appendApiServer = <C extends Config, T extends ServerContext<C>>(
+  ctx: T, alias: string = DEFAULT_ALIAS
+): T & ApiServerAppend => {
+  const service = createApiServer(alias)
+  const context = ctx as T & ApiServerAppend
+
+  context.registerService(service)
+
+  if (context.getApiServer == null) {
+    context.getApiServer = () => ctx.service(service.alias)
+  }
+
+  return context
+}
+
+

package/src/types.ts

@@ -0,0 +1,26 @@
+
+import type { InitializedService, Layer } from '@owlmeans/context'
+import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
+import '@fastify/middie/types/index.d.ts'
+
+export interface ApiServer extends InitializedService {
+  server: FastifyInstance
+
+  layers: [Layer.System]
+
+  listen: () => Promise<void>
+}
+
+export interface Request extends FastifyRequest { }
+
+export interface Response extends FastifyReply { }
+
+export interface ApiServerAppend {
+  getApiServer: () => ApiServer
+}
+
+export interface Config extends ServerConfig { }
+
+export interface Context<C extends Config = Config> extends ServerContext<C>,
+  ApiServerAppend { }

package/src/utils/context.ts

@@ -0,0 +1,9 @@
+import { assertContext } from '@owlmeans/context'
+import type { Config, Context, Request } from '../types.js'
+import { DEFAULT_ALIAS } from '../consts.js'
+
+export const populateContext = <C extends Config, T extends Context<C>>(req: Request, context: T): void =>
+  void ((req as any)._ctx = context)
+
+export const extractContext = <C extends Config, T extends Context<C>>(req: Request, ctx?: T, location?: string): T =>
+  assertContext<C, T>((req as any)._ctx ?? ctx, location ?? DEFAULT_ALIAS)

package/src/utils/error.ts

@@ -0,0 +1,18 @@
+import { FORBIDDEN_ERROR, SERVER_ERROR, UNAUTHORIZED_ERROR } from '@owlmeans/api'
+import type { FastifyReply } from 'fastify'
+import { AccessError, AuthFailedError } from '../errors.js'
+import { ResilientError } from '@owlmeans/error'
+
+export const handleError = (error: Error, reply: FastifyReply) => {
+  let code: number = SERVER_ERROR
+  if (error instanceof AuthFailedError) {
+    code = UNAUTHORIZED_ERROR
+  } else if (error instanceof AccessError) {
+    code = FORBIDDEN_ERROR
+  }
+  if (!reply.sent) {
+    reply.code(code).send(
+      ResilientError.marshal(ResilientError.ensure(error as Error)).message
+    )
+  }
+}

package/src/utils/guards.ts

@@ -0,0 +1,75 @@
+import { isContextWithoutIds, Layer } from '@owlmeans/context'
+import type { FastifyReply, FastifyRequest } from 'fastify'
+import type { ServerModule } from '@owlmeans/server-module'
+import type { GuardService } from '@owlmeans/module'
+import { provideResponse } from '@owlmeans/module'
+import type { ServerConfig, ServerContext } from '@owlmeans/server-context'
+import { executeResponse, provideRequest } from './payload.js'
+import { AuthFailedError } from '../errors.js'
+import type { Auth } from '@owlmeans/auth'
+
+type Config = ServerConfig
+interface Context<C extends Config = Config> extends ServerContext<C> { }
+
+export const authorize = async <C extends Config, T extends Context<C>>(
+  context: T, module: ServerModule<FastifyRequest>,
+  req: FastifyRequest, reply: FastifyReply
+): Promise<[T, ServerModule<FastifyRequest>]> => {
+  const guards = module.getGuards()
+  if (guards.length > 0) {
+    const response = provideResponse(reply)
+    const request = provideRequest(module.alias, req)
+
+    let guard: GuardService | undefined = undefined
+    for (const alias of guards) {
+      const _guard: GuardService = context.service(alias)
+      if (await _guard.match(request, response)) {
+        guard = _guard
+      }
+      executeResponse(response, reply, true)
+      if (guard != null) {
+        break
+      }
+    }
+
+    if (guard == null) {
+      throw new AuthFailedError()
+    }
+
+    const authResponse = provideResponse<Auth>(reply)
+    if (!await guard.handle<boolean>(request, authResponse)) {
+      throw new AuthFailedError(guard.alias)
+    }
+    executeResponse(authResponse, reply, true)
+    // Guard that returns true and does not provide an error is an optional guard
+    // if (authResponse.value == null) {
+    //   throw SyntaxError(`Guard that returns true and does not provide an error, should provide authorization`)
+    // }
+    request.auth = authResponse.value;
+    if (request.auth != null) {
+      (req as any)._auth = request.auth
+    }
+
+    if (request.auth?.entityId != null) {
+      // @TODO Probably we need to downgrade context in this case
+      if (!isContextWithoutIds(context as any)) {
+        throw SyntaxError(`Context should be without ids during authorization ${context.cfg.layer}:${context.cfg.layerId}`)
+      }
+
+      if (isContextWithoutIds(context as any) && context.cfg.layer !== Layer.Service) {
+        context = await context.updateContext(undefined, Layer.Service)
+        await context.waitForInitialized()
+      }
+      context = await context.updateContext(request.auth.entityId, Layer.Entity)
+      await context.waitForInitialized()
+
+      // We elevate module to the context level if it was changed
+      module = context.module(module.alias)
+      await module.resolve()
+    }
+  }
+  // Update context in request object
+  (req as any)._ctx = context
+
+  return [context, module]
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+
+export * from './error.js'
+export * from './server.js'
+export * from './payload.js'
+export * from './server.js'
+export * from './guards.js'
+export * from './context.js'

package/src/utils/payload.ts

@@ -0,0 +1,62 @@
+import { ModuleOutcome } from '@owlmeans/module'
+import type { AbstractResponse, AbstractRequest } from '@owlmeans/module'
+import type { Request, Response } from '../types.js'
+import { ACCEPTED, CREATED, OK, SERVER_ERROR } from '@owlmeans/api'
+import type { AnySchemaObject } from 'ajv'
+
+export const provideRequest = (alias: string, req: Request, provision?: boolean): AbstractRequest => {
+  provision = provision ?? false
+  return {
+    alias,
+    auth: (req as any)._auth ?? undefined,
+    params: req.params as Record<string, string | number | undefined | null>,
+    body: req.body as Record<string, any>,
+    headers: req.headers,
+    query: req.query as Record<string, string | number | undefined | null>,
+    path: req.url,
+    original: provision ? req : undefined
+  }
+}
+
+/**
+ * @throws {Error} 
+ */
+export const executeResponse = <T>(response: AbstractResponse<T>, reply: Response, throwOnError?: boolean) => {
+  if (response.error != null) {
+    if (throwOnError ?? false) {
+      throw response.error
+    }
+    reply.code(SERVER_ERROR).send(response.error.message)
+  } else if (response.outcome != null) {
+    switch (response.outcome) {
+      case ModuleOutcome.Accepted:
+        reply.code(ACCEPTED).send(response.value)
+        break
+      case ModuleOutcome.Created:
+        reply.code(CREATED).send(response.value)
+        break
+      case ModuleOutcome.Ok:
+      default:
+        reply.code(OK).send(response.value)
+    }
+  }
+}
+
+
+export const fixFormatDates = (schema: AnySchemaObject) => {
+  if (schema.type === 'object') {
+    if (schema.format === 'date-time') {
+      schema.type = 'string'
+      schema.format = 'date-time'
+      if (schema.required != null) {
+        delete schema.required
+      }
+    } else if (schema.properties != null) {
+      schema.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([key, value]) => [key, fixFormatDates(value as AnySchemaObject)])
+      )
+    }
+  }
+
+  return schema
+}

package/src/utils/server.ts

@@ -0,0 +1,70 @@
+import { AppType } from '@owlmeans/context'
+import type { FastifyReply, FastifyRequest } from 'fastify'
+import { assertContext } from '@owlmeans/context'
+import type { FixerService, ServerModule } from '@owlmeans/server-module'
+import type { CommonModule } from '@owlmeans/module'
+import type { GateService } from '@owlmeans/module'
+import { provideResponse } from '@owlmeans/module'
+import type { ServerContext, ServerConfig } from '@owlmeans/server-context'
+import { ResilientError } from '@owlmeans/error'
+import { OK } from '@owlmeans/api'
+import { handleError } from './error.js'
+import { executeResponse, provideRequest } from './payload.js'
+import { authorize } from './guards.js'
+import { RouteProtocols } from '@owlmeans/route'
+
+type Config = ServerConfig
+type Context = ServerContext<Config>
+
+export const canServeModule = (context: Context, module: CommonModule): module is ServerModule<unknown> => {
+  if (module.route.route.type !== AppType.Backend) {
+    return false
+  }
+  if (module.route.route.service != null && module.route.route.service !== context.cfg.service) {
+    return false
+  }
+  if (module.route.route.protocol === RouteProtocols.SOCKET) {
+    return false
+  }
+
+  return 'isIntermediate' in module.route
+}
+
+export const createServerHandler = (module: ServerModule<FastifyRequest>, location: string) =>
+  async (req: FastifyRequest, reply: FastifyReply) => {
+    // We passed context using fastify request object
+    let context = assertContext<Config, Context>((req as any)._ctx, location)
+    try {
+      const authorized = await authorize(context, module, req, reply)
+      context = authorized[0]
+      module = authorized[1]
+
+      const response = provideResponse(reply)
+      const request = provideRequest(module.alias, req, true)
+
+      const gates = module.getGates()
+      for (const [srv, params] of gates) {
+        const gate: GateService = context.service(srv)
+        await gate.assert(request, response, params)
+        executeResponse(response, reply, true)
+      }
+
+      await module.handle(request, response)
+
+      executeResponse(response, reply, true)
+      if (!reply.sent) {
+        console.warn(`SENDS DEFAULT RESPONSE: ${module.alias}`)
+        reply.code(OK).send(response.value)
+      }
+    } catch (error) {
+      console.error(`Error in ${module.alias} (${location})`)
+      console.error(JSON.stringify(error, null, 2))
+      console.error(error)
+      if (module.fixer != null) {
+        const fixer: FixerService = context.service(module.fixer)
+        fixer.handle(reply, ResilientError.ensure(error as Error))
+        return
+      }
+      handleError(error as Error, reply)
+    }
+  }