@furystack/rest-service 12.3.5 → 14.0.0

package/src/static-server-manager.ts

@@ -1,90 +0,0 @@
-import { Injectable, Injected } from '@furystack/inject'
-import { PathHelper } from '@furystack/utils'
-import { createReadStream } from 'fs'
-import { access, stat } from 'fs/promises'
-import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'http'
-import { join, normalize, sep } from 'path'
-import { getMimeForFile } from './mime-types.js'
-import { ServerManager } from './server-manager.js'
-
-export interface StaticServerOptions {
-  baseUrl: string
-  path: string
-  hostName?: string
-  port: number
-  fallback?: string
-  headers?: OutgoingHttpHeaders
-}
-
-@Injectable({ lifetime: 'singleton' })
-export class StaticServerManager {
-  @Injected(ServerManager)
-  declare private readonly serverManager: ServerManager
-
-  private async sendFile({
-    fullPath,
-    headers,
-    res,
-  }: {
-    fullPath: string
-    res: ServerResponse
-    headers?: OutgoingHttpHeaders
-  }) {
-    const { size } = await stat(fullPath)
-
-    await access(fullPath)
-
-    const head = {
-      ...headers,
-      'Content-Length': size,
-      'Content-Type': getMimeForFile(fullPath),
-    }
-    Object.entries(head).map(([key, value]) => res.setHeader(key, value))
-    await new Promise<void>((resolve, reject) =>
-      createReadStream(fullPath, { autoClose: true }).once('finish', resolve).once('error', reject).pipe(res),
-    )
-  }
-
-  public shouldExec =
-    (baseUrl: string) =>
-    ({ req }: { req: Pick<IncomingMessage, 'url' | 'method'> }) =>
-      req.url && req.method?.toUpperCase() === 'GET' && PathHelper.matchesBaseUrl(req.url, baseUrl) ? true : false
-
-  private onRequest = ({
-    path,
-    baseUrl,
-    fallback,
-    headers,
-  }: {
-    path: string
-    baseUrl: string
-    fallback?: string
-    headers?: OutgoingHttpHeaders
-  }) => {
-    return async ({ req, res }: { req: IncomingMessage; res: ServerResponse }) => {
-      const extractedPath = PathHelper.extractPath(req.url as string, baseUrl)
-      const filePath = (extractedPath || '/').replaceAll('/', sep)
-      const fullPath = normalize(join(path, filePath))
-
-      try {
-        await this.sendFile({ fullPath, res, headers })
-      } catch (error) {
-        if (fallback) {
-          await this.sendFile({ fullPath: normalize(join(path, fallback)), res, headers })
-        } else {
-          res.writeHead(404, { 'Content-Type': 'text/plain' })
-          res.end('Not found')
-        }
-      }
-    }
-  }
-
-  public async addStaticSite(options: StaticServerOptions) {
-    const server = await this.serverManager.getOrCreate({ hostName: options.hostName, port: options.port })
-
-    server.apis.push({
-      shouldExec: this.shouldExec(options.baseUrl),
-      onRequest: this.onRequest({ ...options }),
-    })
-  }
-}

package/src/swagger/generate-swagger-json.spec.ts

@@ -1,250 +0,0 @@
-import type { ApiEndpointSchema, ParameterObject, ReferenceObject, ResponseObject } from '@furystack/rest'
-import { describe, expect, it } from 'vitest'
-import { generateSwaggerJsonFromApiSchema } from '../openapi/generate-openapi-document.js'
-
-describe('generateSwaggerJsonFromApiSchema', () => {
-  it('Should generate a basic Swagger document with correct OpenAPI structure', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/test': {
-          path: '/api/test',
-          isAuthenticated: false,
-          schemaName: 'Test',
-          schema: { type: 'object', properties: { id: { type: 'string' } } },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check basic structure
-    expect(result.openapi).toBe('3.1.0')
-    expect(result.info.title).toBe('FuryStack API')
-    expect(result.info.version).toBe('1.0.0')
-
-    // Check security scheme is defined correctly for cookie-based auth
-    expect(result.components?.securitySchemes?.cookieAuth).toEqual({
-      type: 'apiKey',
-      in: 'cookie',
-      name: 'session',
-    })
-  })
-
-  it('Should convert API endpoints to OpenAPI paths correctly', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/users': {
-          path: '/api/users',
-          isAuthenticated: true,
-          schemaName: 'UserCollection',
-          schema: { type: 'array', items: { type: 'object' } },
-        },
-        '/api/users/:id': {
-          path: '/api/users/:id',
-          isAuthenticated: true,
-          schemaName: 'User',
-          schema: { type: 'object', properties: { id: { type: 'string' } } },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check paths
-    expect(result.paths?.['/api/users']).toBeDefined()
-    expect(result.paths?.['/api/users/{id}']).toBeDefined()
-
-    // Check methods
-    expect(result.paths?.['/api/users']?.get).toBeDefined()
-    expect(result.paths?.['/api/users/{id}']?.get).toBeDefined()
-
-    // Check security - should use cookieAuth for authenticated endpoints
-    expect(result.paths?.['/api/users']?.get?.security).toEqual([{ cookieAuth: [] }])
-    expect(result.paths?.['/api/users/{id}']?.get?.security).toEqual([{ cookieAuth: [] }])
-  })
-
-  it('Should extract path parameters correctly', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/users/:userId/posts/:postId': {
-          path: '/api/users/:userId/posts/:postId',
-          isAuthenticated: false,
-          schemaName: 'Post',
-          schema: { type: 'object' },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check path parameters
-    const parameters = result.paths?.['/api/users/{userId}/posts/{postId}']?.get?.parameters as ParameterObject[]
-    expect(parameters).toHaveLength(2)
-    expect(parameters?.[0].name).toBe('userId')
-    expect(parameters?.[0].in).toBe('path')
-    expect(parameters?.[0].required).toBe(true)
-    expect(parameters?.[1].name).toBe('postId')
-    expect(parameters?.[1].in).toBe('path')
-    expect(parameters?.[1].required).toBe(true)
-  })
-
-  it('Should handle different HTTP methods correctly', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/resource': {
-          path: '/api/resource',
-          isAuthenticated: false,
-          schemaName: 'Resource',
-          schema: { type: 'object' },
-        },
-      },
-      POST: {
-        '/api/resource': {
-          path: '/api/resource',
-          isAuthenticated: true,
-          schemaName: 'ResourceInput',
-          schema: { type: 'object' },
-        },
-      },
-      PUT: {
-        '/api/resource/:id': {
-          path: '/api/resource/:id',
-          isAuthenticated: true,
-          schemaName: 'ResourceUpdate',
-          schema: { type: 'object' },
-        },
-      },
-      DELETE: {
-        '/api/resource/:id': {
-          path: '/api/resource/:id',
-          isAuthenticated: true,
-          schemaName: 'ResourceDelete',
-          schema: { type: 'object' },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check multiple methods on same path
-    expect(result.paths?.['/api/resource'].get).toBeDefined()
-    expect(result.paths?.['/api/resource'].post).toBeDefined()
-    expect(result.paths?.['/api/resource/{id}'].put).toBeDefined()
-    expect(result.paths?.['/api/resource/{id}'].delete).toBeDefined()
-
-    // Verify security is applied correctly based on isAuthenticated
-    expect(result.paths?.['/api/resource'].get?.security).toEqual([])
-    expect(result.paths?.['/api/resource'].post?.security).toEqual([{ cookieAuth: [] }])
-  })
-
-  it('Should include schemas in components', () => {
-    const testSchema = {
-      type: 'object',
-      properties: {
-        id: { type: 'string' },
-        name: { type: 'string' },
-        age: { type: 'number' },
-      },
-    }
-
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/test': {
-          path: '/api/test',
-          isAuthenticated: false,
-          schemaName: 'TestModel',
-          schema: testSchema,
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check schema is included in components
-    expect(result.components?.schemas?.TestModel).toEqual(testSchema)
-  })
-
-  it('Should handle responses with correct status codes and content types', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/test': {
-          path: '/api/test',
-          isAuthenticated: false,
-          schemaName: 'Test',
-          schema: { type: 'object' },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check response structure
-    const responses = result.paths?.['/api/test'].get?.responses as Record<string, ResponseObject>
-
-    const response200 = responses?.['200']
-    expect(response200).toBeDefined()
-    expect(response200.description).toBe('Successful operation')
-    expect((response200.content?.['application/json']?.schema as ReferenceObject).$ref).toBe(
-      '#/components/schemas/Test',
-    )
-    expect(responses?.['401']).toBeDefined()
-    expect(responses?.['500']).toBeDefined()
-    expect(responses?.['401'].description).toBe('Unauthorized')
-    expect(responses?.['500'].description).toBe('Internal server error')
-  })
-
-  it('Should use empty path object if it does not exist - for code coverage', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/test': {
-          path: '/api/test',
-          isAuthenticated: false,
-          schemaName: 'Test',
-          schema: { type: 'object' },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // This test is mainly for coverage, checking that the path initialization logic works
-    expect(result.paths?.['/api/test']).toBeDefined()
-  })
-
-  it('Should handle endpoints without schemas', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/no-schema': {
-          path: '/api/no-schema',
-          isAuthenticated: false,
-          schemaName: 'EmptySchema',
-          schema: null as unknown,
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Should still create the path without errors
-    expect(result.paths?.['/api/no-schema']).toBeDefined()
-    expect(result.paths?.['/api/no-schema'].get).toBeDefined()
-  })
-
-  it('Should use operationId based on method and path', () => {
-    const api: ApiEndpointSchema['endpoints'] = {
-      GET: {
-        '/api/users/:id/profile': {
-          path: '/api/users/:id/profile',
-          isAuthenticated: false,
-          schemaName: 'UserProfile',
-          schema: { type: 'object' },
-        },
-      },
-    }
-
-    const result = generateSwaggerJsonFromApiSchema({ api })
-
-    // Check operationId format
-    expect(result.paths?.['/api/users/{id}/profile'].get?.operationId).toBe('get_api_users_id_profile')
-  })
-})