{
- // eslint-disable-next-line
- (
- path: PathParams,
- ...handlers: (RequestHandler | Partial | Application)[]
- ): T
- }
-}
diff --git a/packages/express/src/handlers.ts b/packages/express/src/handlers.ts
deleted file mode 100644
index 73c162759c..0000000000
--- a/packages/express/src/handlers.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-import path from 'path'
-import { NotFound, GeneralError } from '@feathersjs/errors'
-import { Request, Response, NextFunction, ErrorRequestHandler, RequestHandler } from 'express'
-
-const defaults = {
- public: path.resolve(__dirname, '..', 'public'),
- logger: console
-}
-const defaultHtmlError = path.resolve(defaults.public, 'default.html')
-
-export function notFound({ verbose = false } = {}): RequestHandler {
- return function (req: Request, _res: Response, next: NextFunction) {
- const url = `${req.url}`
- const message = `Page not found${verbose ? ': ' + url : ''}`
-
- next(new NotFound(message, { url }))
- }
-}
-
-export type ErrorHandlerOptions = {
- public?: string
- logger?: boolean | { error?: (msg: any) => void; info?: (msg: any) => void }
- html?: any
- json?: any
-}
-
-export function errorHandler(_options: ErrorHandlerOptions = {}): ErrorRequestHandler {
- const options = Object.assign({}, defaults, _options)
-
- if (typeof options.html === 'undefined') {
- options.html = {
- 401: path.resolve(options.public, '401.html'),
- 404: path.resolve(options.public, '404.html'),
- default: defaultHtmlError
- }
- }
-
- if (typeof options.json === 'undefined') {
- options.json = {}
- }
-
- return function (error: any, req: Request, res: Response, next: NextFunction) {
- // Set the error code for HTTP processing semantics
- error.code = !isNaN(parseInt(error.code, 10)) ? parseInt(error.code, 10) : 500
-
- // Log the error if it didn't come from a service method call
- if (options.logger && typeof options.logger.error === 'function' && !res.hook) {
- if (error.code >= 500) {
- options.logger.error(error)
- } else {
- options.logger.info(error)
- }
- }
-
- if (error.type !== 'FeathersError') {
- const oldError = error
-
- error = oldError.errors
- ? new GeneralError(oldError.message, {
- errors: oldError.errors
- })
- : new GeneralError(oldError.message)
-
- if (oldError.stack) {
- error.stack = oldError.stack
- }
- }
-
- const formatter: { [key: string]: any } = {}
-
- // If the developer passed a custom function for ALL html errors
- if (typeof options.html === 'function') {
- formatter['text/html'] = options.html
- } else {
- let file = options.html[error.code]
- if (!file) {
- file = options.html.default || defaultHtmlError
- }
- // If the developer passed a custom function for individual html errors
- if (typeof file === 'function') {
- formatter['text/html'] = file
- } else {
- formatter['text/html'] = function () {
- res.set('Content-Type', 'text/html')
- res.sendFile(file)
- }
- }
- }
-
- // If the developer passed a custom function for ALL json errors
- if (typeof options.json === 'function') {
- formatter['application/json'] = options.json
- } else {
- const handler = options.json[error.code] || options.json.default
- // If the developer passed a custom function for individual json errors
- if (typeof handler === 'function') {
- formatter['application/json'] = handler
- } else {
- // Don't show stack trace if it is a 404 error
- if (error.code === 404) {
- error.stack = null
- }
-
- formatter['application/json'] = function () {
- const output = Object.assign({}, error.toJSON())
-
- if (process.env.NODE_ENV === 'production') {
- delete output.stack
- }
-
- res.set('Content-Type', 'application/json')
- res.json(output)
- }
- }
- }
-
- res.status(error.code)
-
- const contentType = req.headers['content-type'] || ''
- const accepts = req.headers.accept || ''
-
- // by default just send back json
- if (contentType.indexOf('json') !== -1 || accepts.indexOf('json') !== -1) {
- formatter['application/json'](error, req, res, next)
- } else if (options.html && (contentType.indexOf('html') !== -1 || accepts.indexOf('html') !== -1)) {
- formatter['text/html'](error, req, res, next)
- } else {
- // TODO (EK): Maybe just return plain text
- formatter['application/json'](error, req, res, next)
- }
- }
-}
diff --git a/packages/express/src/index.ts b/packages/express/src/index.ts
deleted file mode 100644
index 675ae253d3..0000000000
--- a/packages/express/src/index.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import express, { Express } from 'express'
-import { Application as FeathersApplication, defaultServiceMethods } from '@feathersjs/feathers'
-import { routing } from '@feathersjs/transport-commons'
-import { createDebug } from '@feathersjs/commons'
-import cors from 'cors'
-import compression from 'compression'
-
-import { rest, RestOptions, formatter } from './rest'
-import { errorHandler, notFound, ErrorHandlerOptions } from './handlers'
-import { Application, ExpressOverrides } from './declarations'
-import { AuthenticationSettings, authenticate, parseAuthentication } from './authentication'
-import {
- default as original,
- static as serveStatic,
- json,
- raw,
- text,
- urlencoded,
- query,
- Router
-} from 'express'
-
-export {
- original,
- serveStatic,
- serveStatic as static,
- json,
- raw,
- text,
- urlencoded,
- query,
- rest,
- Router,
- RestOptions,
- formatter,
- errorHandler,
- notFound,
- Application,
- ErrorHandlerOptions,
- ExpressOverrides,
- AuthenticationSettings,
- parseAuthentication,
- authenticate,
- cors,
- compression
-}
-
-const debug = createDebug('@feathersjs/express')
-
-export default function feathersExpress(
- feathersApp?: FeathersApplication,
- expressApp: Express = express()
-): Application {
- if (!feathersApp) {
- return expressApp as any
- }
-
- if (typeof feathersApp.setup !== 'function') {
- throw new Error('@feathersjs/express requires a valid Feathers application instance')
- }
-
- const app = expressApp as any as Application
- const { use: expressUse, listen: expressListen } = expressApp as any
- const { use: feathersUse, teardown: feathersTeardown } = feathersApp
-
- Object.assign(app, {
- use(location: string & keyof S, ...rest: any[]) {
- let service: any
- let options = {}
-
- const middleware = rest.reduce(
- function (middleware, arg) {
- if (typeof arg === 'function' || Array.isArray(arg)) {
- middleware[service ? 'after' : 'before'].push(arg)
- } else if (!service) {
- service = arg
- } else if (arg.methods || arg.events || arg.express || arg.koa) {
- options = arg
- } else {
- throw new Error('Invalid options passed to app.use')
- }
- return middleware
- },
- {
- before: [],
- after: []
- }
- )
-
- const hasMethod = (methods: string[]) =>
- methods.some((name) => service && typeof service[name] === 'function')
-
- // Check for service (any object with at least one service method)
- if (hasMethod(['handle', 'set']) || !hasMethod(defaultServiceMethods)) {
- debug('Passing app.use call to Express app')
- return expressUse.call(this, location, ...rest)
- }
-
- debug('Registering service with middleware', middleware)
- // Since this is a service, call Feathers `.use`
- feathersUse.call(this, location, service, {
- express: middleware,
- ...options
- })
-
- return this
- },
-
- async listen(...args: any[]) {
- const server = expressListen.call(this, ...args)
-
- this.server = server
- await this.setup(server)
- debug('Feathers application listening')
-
- return server
- }
- } as Application)
-
- const appDescriptors = {
- ...Object.getOwnPropertyDescriptors(Object.getPrototypeOf(app)),
- ...Object.getOwnPropertyDescriptors(app)
- }
- const newDescriptors = {
- ...Object.getOwnPropertyDescriptors(Object.getPrototypeOf(feathersApp)),
- ...Object.getOwnPropertyDescriptors(feathersApp)
- }
-
- // Copy all non-existing properties (including non-enumerables)
- // that don't already exist on the Express app
- Object.keys(newDescriptors).forEach((prop) => {
- const appProp = appDescriptors[prop]
- const newProp = newDescriptors[prop]
-
- if (appProp === undefined && newProp !== undefined) {
- Object.defineProperty(expressApp, prop, newProp)
- }
- })
-
- // Assign teardown and setup which will also make sure that hooks are initialized
- app.setup = feathersApp.setup as any
- app.teardown = async function teardown(server?: any) {
- return feathersTeardown.call(this, server).then(
- () =>
- new Promise((resolve, reject) => {
- if (this.server) {
- this.server.close((e) => (e ? reject(e) : resolve(this)))
- } else {
- resolve(this)
- }
- })
- )
- }
-
- app.configure(routing() as any)
- app.use((req, _res, next) => {
- req.feathers = { ...req.feathers, provider: 'rest' }
- return next()
- })
-
- return app
-}
-
-if (typeof module !== 'undefined') {
- module.exports = Object.assign(feathersExpress, module.exports)
-}
diff --git a/packages/express/src/rest.ts b/packages/express/src/rest.ts
deleted file mode 100644
index 6b4cc1c9d9..0000000000
--- a/packages/express/src/rest.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { Request, Response, RequestHandler, Router } from 'express'
-import { MethodNotAllowed } from '@feathersjs/errors'
-import { createDebug } from '@feathersjs/commons'
-import { http } from '@feathersjs/transport-commons'
-import { createContext, defaultServiceMethods, getServiceOptions } from '@feathersjs/feathers'
-
-import { AuthenticationSettings, parseAuthentication } from './authentication'
-import { Application } from './declarations'
-
-const debug = createDebug('@feathersjs/express/rest')
-
-const toHandler = (
- func: (req: Request, res: Response, next: () => void) => Promise
-): RequestHandler => {
- return (req, res, next) => func(req, res, next).catch((error) => next(error))
-}
-
-const serviceMiddleware = (): RequestHandler => {
- return toHandler(async (req, res, next) => {
- const { query, headers, path, body: data, method: httpMethod } = req
- const methodOverride = req.headers[http.METHOD_HEADER] as string | undefined
-
- // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
- const { service, params: { __id: id = null, ...route } = {} } = req.lookup!
- const method = http.getServiceMethod(httpMethod, id, methodOverride)
- const { methods } = getServiceOptions(service)
-
- debug(`Found service for path ${path}, attempting to run '${method}' service method`)
-
- if (!methods.includes(method) || defaultServiceMethods.includes(methodOverride)) {
- const error = new MethodNotAllowed(`Method \`${method}\` is not supported by this endpoint.`)
- res.statusCode = error.code
- throw error
- }
-
- const createArguments = http.argumentsFor[method as 'get'] || http.argumentsFor.default
- const params = { query, headers, route, ...req.feathers }
- const args = createArguments({ id, data, params })
- const contextBase = createContext(service, method, { http: {} })
- res.hook = contextBase
-
- const context = await (service as any)[method](...args, contextBase)
- res.hook = context
-
- const response = http.getResponse(context)
- res.statusCode = response.status
- res.set(response.headers)
- res.data = response.body
-
- return next()
- })
-}
-
-const servicesMiddleware = (): RequestHandler => {
- return toHandler(async (req, res, next) => {
- const app = req.app as any as Application
- const lookup = app.lookup(req.path)
-
- if (!lookup) {
- return next()
- }
-
- req.lookup = lookup
-
- const options = getServiceOptions(lookup.service)
- const middleware = options.express.composed
-
- return middleware(req, res, next)
- })
-}
-
-export const formatter: RequestHandler = (_req, res, next) => {
- if (res.data === undefined) {
- return next()
- }
-
- res.format({
- 'application/json'() {
- res.json(res.data)
- }
- })
-}
-
-export type RestOptions = {
- formatter?: RequestHandler
- authentication?: AuthenticationSettings
-}
-
-export const rest = (options?: RestOptions | RequestHandler) => {
- options = typeof options === 'function' ? { formatter: options } : options || {}
-
- const formatterMiddleware = options.formatter || formatter
- const authenticationOptions = options.authentication
-
- return (app: Application) => {
- if (typeof app.route !== 'function') {
- throw new Error('@feathersjs/express/rest needs an Express compatible app.')
- }
-
- app.use(parseAuthentication(authenticationOptions))
- app.use(servicesMiddleware())
-
- app.mixins.push((_service, _path, options) => {
- const { express: { before = [], after = [] } = {} } = options
-
- const middlewares = [].concat(before, serviceMiddleware(), after, formatterMiddleware)
- const middleware = Router().use(middlewares)
-
- options.express ||= {}
- options.express.composed = middleware
- })
- }
-}
diff --git a/packages/express/test/authentication.test.ts b/packages/express/test/authentication.test.ts
deleted file mode 100644
index a821c1517a..0000000000
--- a/packages/express/test/authentication.test.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import omit from 'lodash/omit'
-import { strict as assert } from 'assert'
-import { default as _axios } from 'axios'
-import { feathers } from '@feathersjs/feathers'
-import { createApplication } from '@feathersjs/authentication-local/test/fixture'
-import { authenticate, AuthenticationResult } from '@feathersjs/authentication'
-import * as express from '../src'
-
-const expressify = express.default
-const axios = _axios.create({
- baseURL: 'http://localhost:9876/'
-})
-
-describe('@feathersjs/express/authentication', () => {
- const email = 'expresstest@authentication.com'
- const password = 'superexpress'
-
- let app: express.Application
- let user: any
- let authResult: AuthenticationResult
-
- before(async () => {
- const expressApp = expressify(feathers()).use(express.json()).configure(express.rest())
-
- app = createApplication(expressApp as any) as unknown as express.Application
-
- await app.listen(9876)
-
- app.use('/dummy', {
- get(id, params) {
- return Promise.resolve({ id, params })
- }
- })
-
- // @ts-ignore
- app.use('/protected', express.authenticate('jwt'), (req, res) => {
- res.json(req.feathers.user)
- })
-
- app.use(
- express.errorHandler({
- logger: false
- })
- )
-
- app.service('dummy').hooks({
- before: [authenticate('jwt')]
- })
-
- const result = await app.service('users').create({ email, password })
-
- user = result
-
- const res = await axios.post('/authentication', {
- strategy: 'local',
- password,
- email
- })
-
- authResult = res.data
- })
-
- after(() => app.teardown())
-
- describe('service authentication', () => {
- it('successful local authentication', () => {
- assert.ok(authResult.accessToken)
- assert.deepStrictEqual(omit(authResult.authentication, 'payload'), {
- strategy: 'local'
- })
- assert.strictEqual(authResult.user.email, email)
- assert.strictEqual(authResult.user.password, undefined)
- })
-
- it('local authentication with wrong password fails', async () => {
- try {
- await axios.post('/authentication', {
- strategy: 'local',
- password: 'wrong',
- email
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- const { data } = error.response
- assert.strictEqual(data.name, 'NotAuthenticated')
- assert.strictEqual(data.message, 'Invalid login')
- }
- })
-
- it('authenticating with JWT works but returns same accessToken', async () => {
- const { accessToken } = authResult
- const { data } = await axios.post('/authentication', {
- strategy: 'jwt',
- accessToken
- })
-
- assert.strictEqual(data.accessToken, accessToken)
- assert.strictEqual(data.authentication.strategy, 'jwt')
- assert.strictEqual(data.authentication.payload.sub, user.id.toString())
- assert.strictEqual(data.user.email, email)
- })
-
- it('can make a protected request with Authorization header', async () => {
- const { accessToken } = authResult
-
- const {
- data,
- data: { params }
- } = await axios.get('/dummy/dave', {
- headers: {
- Authorization: accessToken
- }
- })
-
- assert.strictEqual(data.id, 'dave')
- assert.deepStrictEqual(params.user, user)
- assert.strictEqual(params.authentication.accessToken, accessToken)
- })
-
- it('errors when there are no authStrategies and parseStrategies', async () => {
- const { accessToken } = authResult
- app.get('authentication').authStrategies = []
- delete app.get('authentication').parseStrategies
-
- try {
- await axios.get('/dummy/dave', {
- headers: {
- Authorization: accessToken
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.strictEqual(error.response.data.name, 'NotAuthenticated')
- app.get('authentication').authStrategies = ['jwt', 'local']
- }
- })
-
- it('can make a protected request with Authorization header and bearer scheme', async () => {
- const { accessToken } = authResult
-
- const {
- data,
- data: { params }
- } = await axios.get('/dummy/dave', {
- headers: {
- Authorization: ` Bearer: ${accessToken}`
- }
- })
-
- assert.strictEqual(data.id, 'dave')
- assert.deepStrictEqual(params.user, user)
- assert.strictEqual(params.authentication.accessToken, accessToken)
- })
- })
-
- describe('authenticate middleware', () => {
- it('errors without valid strategies', () => {
- try {
- // @ts-ignore
- authenticate()
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.strictEqual(error.message, 'The authenticate hook needs at least one allowed strategy')
- }
- })
-
- it('protected endpoint fails when JWT is not present', () => {
- return axios
- .get('/protected')
- .then(() => {
- assert.fail('Should never get here')
- })
- .catch((error) => {
- const { data } = error.response
-
- assert.strictEqual(data.name, 'NotAuthenticated')
- assert.strictEqual(data.message, 'Not authenticated')
- })
- })
-
- it.skip('protected endpoint fails with invalid Authorization header', async () => {
- try {
- await axios.get('/protected', {
- headers: {
- Authorization: 'Bearer: something wrong'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- const { data } = error.response
-
- assert.strictEqual(data.name, 'NotAuthenticated')
- assert.strictEqual(data.message, 'Not authenticated')
- }
- })
-
- it('can request protected endpoint with JWT present', async () => {
- const { data } = await axios.get('/protected', {
- headers: {
- Authorization: `Bearer ${authResult.accessToken}`
- }
- })
-
- assert.strictEqual(data.email, user.email)
- assert.strictEqual(data.id, user.id)
- assert.strictEqual(data.password, user.password)
- })
- })
-})
diff --git a/packages/express/test/error-handler.test.ts b/packages/express/test/error-handler.test.ts
deleted file mode 100644
index e12b653d88..0000000000
--- a/packages/express/test/error-handler.test.ts
+++ /dev/null
@@ -1,399 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function */
-import { strict as assert } from 'assert'
-import express, { Request, Response, NextFunction } from 'express'
-import axios from 'axios'
-import fs from 'fs'
-import { join } from 'path'
-import { BadRequest, NotAcceptable, NotAuthenticated, NotFound, PaymentError } from '@feathersjs/errors'
-
-import { errorHandler } from '../src'
-
-const content = 'Error'
-
-const htmlHandler = function (_error: Error, _req: Request, res: Response, _next: NextFunction) {
- res.send(content)
-}
-
-const jsonHandler = function (error: Error, _req: Request, res: Response, _next: NextFunction) {
- res.json(error)
-}
-
-describe('error-handler', () => {
- describe('supports catch-all custom handlers', function () {
- before(function () {
- this.app = express()
- .get('/error', function (_req: Request, _res: Response, next: NextFunction) {
- next(new Error('Something went wrong'))
- })
- .use(
- errorHandler({
- html: htmlHandler,
- json: jsonHandler
- })
- )
-
- this.server = this.app.listen(5050)
- })
-
- after(function (done) {
- this.server.close(done)
- })
-
- describe('JSON handler', () => {
- const options = {
- url: 'http://localhost:5050/error',
- headers: {
- 'Content-Type': 'application/json',
- Accept: 'application/json'
- }
- }
-
- it('can send a custom response', async () => {
- try {
- await axios(options)
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.deepEqual(error.response.data, {
- name: 'GeneralError',
- message: 'Something went wrong',
- code: 500,
- className: 'general-error'
- })
- }
- })
- })
- })
-
- describe('supports error-code specific custom handlers', () => {
- describe('HTML handler', () => {
- const req = {
- headers: { 'content-type': 'text/html' }
- }
- const makeRes = (errCode: number, props?: any) => {
- return Object.assign(
- {
- set() {},
- status(code: number) {
- assert.equal(code, errCode)
- }
- },
- props
- )
- }
-
- it('if the value is a string, calls res.sendFile', (done) => {
- const err = new NotAuthenticated()
- const middleware = errorHandler({
- logger: null,
- html: { 401: 'path/to/401.html' }
- })
- const res = makeRes(401, {
- sendFile(f: any) {
- assert.equal(f, 'path/to/401.html')
- done()
- }
- })
- ;(middleware as any)(err, req, res)
- })
-
- it('if the value is a function, calls as middleware ', (done) => {
- const err = new PaymentError()
- const res = makeRes(402)
- const middleware = errorHandler({
- logger: null,
- html: {
- 402: (_err: any, _req: any, _res: any) => {
- assert.equal(_err, err)
- assert.equal(_req, req)
- assert.equal(_res, res)
- done()
- }
- }
- })
- ;(middleware as any)(err, req, res)
- })
-
- it('falls back to default if error code config is available', (done) => {
- const err = new NotAcceptable()
- const res = makeRes(406)
- const middleware = errorHandler({
- logger: null,
- html: {
- default: (_err: any, _req: any, _res: any) => {
- assert.equal(_err, err)
- assert.equal(_req, req)
- assert.equal(_res, res)
- done()
- }
- }
- })
- ;(middleware as any)(err, req, res)
- })
- })
-
- describe('JSON handler', () => {
- const req = {
- headers: { 'content-type': 'application/json' }
- }
- const makeRes = (errCode: number, props?: any) => {
- return Object.assign(
- {
- set() {},
- status(code: number) {
- assert.equal(code, errCode)
- }
- },
- props
- )
- }
-
- it('calls res.json by default', (done) => {
- const err = new NotAuthenticated()
- const middleware = errorHandler({
- logger: null,
- json: {}
- })
- const res = makeRes(401, {
- json(obj: any) {
- assert.deepEqual(obj, err.toJSON())
- done()
- }
- })
- ;(middleware as any)(err, req, res)
- })
-
- it('if the value is a function, calls as middleware ', (done) => {
- const err = new PaymentError()
- const res = makeRes(402)
- const middleware = errorHandler({
- logger: null,
- json: {
- 402: (_err: any, _req: any, _res: any) => {
- assert.equal(_err, err)
- assert.equal(_req, req)
- assert.equal(_res, res)
- done()
- }
- }
- })
- ;(middleware as any)(err, req, res)
- })
-
- it('falls back to default if error code config is available', (done) => {
- const err = new NotAcceptable()
- const res = makeRes(406)
- const middleware = errorHandler({
- logger: null,
- json: {
- default: (_err: any, _req: any, _res: any) => {
- assert.equal(_err, err)
- assert.equal(_req, req)
- assert.equal(_res, res)
- done()
- }
- }
- })
- ;(middleware as any)(err, req, res)
- })
- })
- })
-
- describe('use as app error handler', function () {
- before(function () {
- this.app = express()
- .get('/error', function (_req: Request, _res: Response, next: NextFunction) {
- next(new Error('Something went wrong'))
- })
- .get('/string-error', function (_req: Request, _res: Response, next: NextFunction) {
- const e: any = new Error('Something was not found')
- e.code = '404'
-
- next(e)
- })
- .get('/bad-request', function (_req: Request, _res: Response, next: NextFunction) {
- next(
- new BadRequest({
- message: 'Invalid Password',
- errors: [
- {
- path: 'password',
- value: null,
- message: "'password' cannot be 'null'"
- }
- ]
- })
- )
- })
- .use(function (_req: Request, _res: Response, next: NextFunction) {
- next(new NotFound('File not found'))
- })
- .use(
- errorHandler({
- logger: null
- })
- )
-
- this.server = this.app.listen(5050)
- })
-
- after(function (done) {
- this.server.close(done)
- })
-
- describe('converts an non-feathers error', () => {
- it('is an instance of GeneralError', async () => {
- try {
- await axios({
- url: 'http://localhost:5050/error',
- responseType: 'json'
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 500)
- assert.deepEqual(error.response.data, {
- name: 'GeneralError',
- message: 'Something went wrong',
- code: 500,
- className: 'general-error'
- })
- }
- })
- })
-
- describe('text/html format', () => {
- it('serves a 404.html', (done) => {
- fs.readFile(join(__dirname, '..', 'public', '404.html'), async function (_err, html) {
- try {
- await axios({
- url: 'http://localhost:5050/path/to/nowhere',
- headers: {
- 'Content-Type': 'text/html',
- Accept: 'text/html'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 404)
- assert.equal(error.response.data, html.toString())
- done()
- }
- })
- })
-
- it('serves a 500.html', (done) => {
- fs.readFile(join(__dirname, '..', 'public', 'default.html'), async function (_err, html) {
- try {
- await axios({
- url: 'http://localhost:5050/error',
- headers: {
- 'Content-Type': 'text/html',
- Accept: 'text/html'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 500)
- assert.equal(error.response.data, html.toString())
- done()
- }
- })
- })
- })
-
- describe('application/json format', () => {
- it('500', async () => {
- try {
- await axios({
- url: 'http://localhost:5050/error',
- headers: {
- 'Content-Type': 'application/json',
- Accept: 'application/json'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 500)
- assert.deepEqual(error.response.data, {
- name: 'GeneralError',
- message: 'Something went wrong',
- code: 500,
- className: 'general-error'
- })
- }
- })
-
- it('404', async () => {
- try {
- await axios({
- url: 'http://localhost:5050/path/to/nowhere',
- headers: {
- 'Content-Type': 'application/json',
- Accept: 'application/json'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 404)
- assert.deepEqual(error.response.data, {
- name: 'NotFound',
- message: 'File not found',
- code: 404,
- className: 'not-found'
- })
- }
- })
-
- it('400', async () => {
- try {
- await axios({
- url: 'http://localhost:5050/bad-request',
- headers: {
- 'Content-Type': 'application/json',
- Accept: 'application/json'
- }
- })
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 400)
- assert.deepEqual(error.response.data, {
- name: 'BadRequest',
- message: 'Invalid Password',
- code: 400,
- className: 'bad-request',
- data: {},
- errors: [
- {
- path: 'password',
- value: null,
- message: "'password' cannot be 'null'"
- }
- ]
- })
- }
- })
- })
-
- it('returns JSON by default', async () => {
- try {
- await axios('http://localhost:5050/bad-request')
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.equal(error.response.status, 400)
- assert.deepEqual(error.response.data, {
- name: 'BadRequest',
- message: 'Invalid Password',
- code: 400,
- className: 'bad-request',
- data: {},
- errors: [
- {
- path: 'password',
- value: null,
- message: "'password' cannot be 'null'"
- }
- ]
- })
- }
- })
- })
-})
diff --git a/packages/express/test/index.test.ts b/packages/express/test/index.test.ts
deleted file mode 100644
index b22566f22d..0000000000
--- a/packages/express/test/index.test.ts
+++ /dev/null
@@ -1,291 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { strict as assert } from 'assert'
-import express, { Request, Response, NextFunction } from 'express'
-import axios from 'axios'
-import fs from 'fs'
-import path from 'path'
-import https from 'https'
-import { feathers, HookContext, Id } from '@feathersjs/feathers'
-
-import { default as feathersExpress, rest, notFound, errorHandler, original, serveStatic } from '../src'
-import { RequestListener } from 'http'
-
-describe('@feathersjs/express', () => {
- const service = {
- async get(id: Id) {
- return { id }
- }
- }
-
- it('exports .default, .original .rest, .notFound and .errorHandler', () => {
- assert.strictEqual(original, express)
- assert.strictEqual(typeof rest, 'function')
- assert.ok(notFound)
- assert.ok(errorHandler)
- })
-
- it('returns an Express application, keeps Feathers service and configuration typings typings', () => {
- type Config = {
- hostname: string
- port: number
- }
-
- const app = feathersExpress, Config>(feathers())
-
- app.set('hostname', 'test.com')
-
- const hostname = app.get('hostname')
-
- assert.strictEqual(hostname, 'test.com')
- assert.strictEqual(typeof app, 'function')
- })
-
- it('allows to use an existing Express instance', () => {
- const expressApp = express()
- const app = feathersExpress(feathers(), expressApp)
-
- assert.strictEqual(app, expressApp)
- })
-
- it('exports `express.rest`', () => {
- assert.ok(typeof rest === 'function')
- })
-
- it('returns a plain express app when no app is provided', () => {
- const app = feathersExpress()
-
- assert.strictEqual(typeof app.use, 'function')
- assert.strictEqual(typeof app.service, 'undefined')
- assert.strictEqual(typeof app.services, 'undefined')
- })
-
- it('errors when app with wrong version is provided', () => {
- try {
- // @ts-ignore
- feathersExpress({})
- } catch (e: any) {
- assert.strictEqual(e.message, '@feathersjs/express requires a valid Feathers application instance')
- }
-
- try {
- const app = feathers()
- app.version = '2.9.9'
-
- feathersExpress(app)
- } catch (e: any) {
- assert.strictEqual(
- e.message,
- '@feathersjs/express requires an instance of a Feathers application version 3.x or later (got 2.9.9)'
- )
- }
-
- try {
- const app = feathers()
- delete app.version
-
- feathersExpress(app)
- } catch (e: any) {
- assert.strictEqual(
- e.message,
- '@feathersjs/express requires an instance of a Feathers application version 3.x or later (got unknown)'
- )
- }
- })
-
- it('Can use Express sub-apps', () => {
- const typedApp = feathers>()
- const app = feathersExpress(typedApp)
- const child = express()
-
- app.use('/path', child)
- assert.strictEqual((child as any).parent, app)
- })
-
- it('Can use express.static', () => {
- const app = feathersExpress(feathers())
-
- app.use('/path', serveStatic(__dirname))
- })
-
- it('has Feathers functionality', async () => {
- const app = feathersExpress(feathers())
-
- app.use('/myservice', service)
-
- app.hooks({
- after: {
- get(hook: HookContext) {
- hook.result.fromAppHook = true
- }
- }
- })
-
- app.service('myservice').hooks({
- after: {
- get(hook: HookContext) {
- hook.result.fromHook = true
- }
- }
- })
-
- const data = await app.service('myservice').get(10)
-
- assert.deepStrictEqual(data, {
- id: 10,
- fromHook: true,
- fromAppHook: true
- })
- })
-
- it('can register a service and start an Express server', async () => {
- const app = feathersExpress(feathers())
- const response = {
- message: 'Hello world'
- }
-
- app.use('/myservice', service)
- app.use((_req: Request, res: Response) => res.json(response))
-
- const server = await app.listen(8787)
- const data = await app.service('myservice').get(10)
-
- assert.deepStrictEqual(data, { id: 10 })
-
- const res = await axios.get('http://localhost:8787')
- assert.deepStrictEqual(res.data, response)
-
- await new Promise((resolve) => server.close(() => resolve(server)))
- })
-
- it('.listen calls .setup', async () => {
- const app = feathersExpress(feathers())
- let called = false
-
- app.use('/myservice', {
- async get(id: Id) {
- return { id }
- },
-
- async setup(appParam, path) {
- assert.strictEqual(appParam, app)
- assert.strictEqual(path, 'myservice')
- called = true
- }
- })
-
- const server = await app.listen(8787)
-
- assert.ok(called)
- await new Promise((resolve) => server.close(() => resolve(server)))
- })
-
- it('.teardown closes http server', async () => {
- const app = feathersExpress(feathers())
- let called = false
-
- const server = await app.listen(8787)
- server.on('close', () => {
- called = true
- })
-
- await app.teardown()
- assert.ok(called)
- })
-
- it('passes middleware as options', () => {
- const feathersApp = feathers()
- const app = feathersExpress(feathersApp)
- const oldUse = feathersApp.use
- const a = (_req: Request, _res: Response, next: NextFunction) => next()
- const b = (_req: Request, _res: Response, next: NextFunction) => next()
- const c = (_req: Request, _res: Response, next: NextFunction) => next()
- const service = {
- async get(id: Id) {
- return { id }
- }
- }
-
- feathersApp.use = function (path, serviceArg, options) {
- assert.strictEqual(path, '/myservice')
- assert.strictEqual(serviceArg, service)
- assert.deepStrictEqual(options.express, {
- before: [a, b],
- after: [c]
- })
- // eslint-disable-next-line prefer-rest-params
- return (oldUse as any).apply(this, arguments)
- }
-
- app.use('/myservice', a, b, service, c)
- })
-
- it('Express wrapped and context.app are the same', async () => {
- const app = feathersExpress(feathers())
-
- app.use('/test', {
- async get(id: Id) {
- return { id }
- }
- })
-
- app.service('test').hooks({
- before: {
- get: [
- (context) => {
- assert.ok(context.app === app)
- }
- ]
- }
- })
-
- assert.deepStrictEqual(await app.service('test').get('testing'), {
- id: 'testing'
- })
- })
-
- it('Works with HTTPS', (done) => {
- const todoService = {
- async get(name: Id) {
- return {
- id: name,
- description: `You have to do ${name}!`
- }
- }
- }
-
- const app = feathersExpress(feathers()).configure(rest())
-
- app.use('/secureTodos', todoService)
-
- const httpsServer = https
- .createServer(
- {
- key: fs.readFileSync(path.join(__dirname, '..', '..', 'tests', 'resources', 'privatekey.pem')),
- cert: fs.readFileSync(path.join(__dirname, '..', '..', 'tests', 'resources', 'certificate.pem')),
- rejectUnauthorized: false,
- requestCert: false
- },
- app as unknown as RequestListener
- )
- .listen(7889)
-
- app.setup(httpsServer)
-
- httpsServer.on('listening', function () {
- const instance = axios.create({
- httpsAgent: new https.Agent({
- rejectUnauthorized: false
- })
- })
-
- instance
- .get('https://localhost:7889/secureTodos/dishes')
- .then((response) => {
- assert.ok(response.status === 200, 'Got OK status code')
- assert.strictEqual(response.data.description, 'You have to do dishes!')
- httpsServer.close(() => done())
- })
- .catch(done)
- })
- })
-})
diff --git a/packages/express/test/not-found-handler.test.ts b/packages/express/test/not-found-handler.test.ts
deleted file mode 100644
index 89db3cf1bd..0000000000
--- a/packages/express/test/not-found-handler.test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { strict as assert } from 'assert'
-import { NotFound } from '@feathersjs/errors'
-
-import { notFound } from '../src'
-
-const handler = notFound as any
-
-describe('not-found-handler', () => {
- it('returns NotFound error', (done) => {
- handler()(
- {
- url: 'some/where',
- headers: {}
- },
- {},
- function (error: any) {
- assert.ok(error instanceof NotFound)
- assert.equal(error.message, 'Page not found')
- assert.deepEqual(error.data, {
- url: 'some/where'
- })
- done()
- }
- )
- })
-
- it('returns NotFound error with URL when verbose', (done) => {
- handler({ verbose: true })(
- {
- url: 'some/where',
- headers: {}
- },
- {},
- function (error: any) {
- assert.ok(error instanceof NotFound)
- assert.equal(error.message, 'Page not found: some/where')
- assert.deepEqual(error.data, {
- url: 'some/where'
- })
- done()
- }
- )
- })
-})
diff --git a/packages/express/test/rest.test.ts b/packages/express/test/rest.test.ts
deleted file mode 100644
index ddc9ff8574..0000000000
--- a/packages/express/test/rest.test.ts
+++ /dev/null
@@ -1,715 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { strict as assert } from 'assert'
-import axios, { AxiosRequestConfig } from 'axios'
-
-import { Server } from 'http'
-import { Request, Response, NextFunction } from 'express'
-import { ApplicationHookMap, feathers, HookContext, Id, Params } from '@feathersjs/feathers'
-import { Service, restTests } from '@feathersjs/tests'
-import { BadRequest } from '@feathersjs/errors'
-
-import * as express from '../src'
-
-const expressify = express.default
-const { rest } = express
-const errorHandler = express.errorHandler({
- logger: false
-})
-
-describe('@feathersjs/express/rest provider', () => {
- describe('base functionality', () => {
- it('throws an error if you did not expressify', () => {
- const app = feathers()
-
- try {
- app.configure(rest() as any)
- assert.ok(false, 'Should never get here')
- } catch (e: any) {
- assert.strictEqual(e.message, '@feathersjs/express/rest needs an Express compatible app.')
- }
- })
-
- it('lets you set the handler manually', async () => {
- const app = expressify(feathers())
-
- app
- .configure(
- rest(function (_req, res) {
- res.format({
- 'text/plain'() {
- res.end(`The todo is: ${res.data.description}`)
- }
- })
- })
- )
- .use('/todo', {
- async get(id: Id) {
- return {
- description: `You have to do ${id}`
- }
- }
- })
-
- const server = await app.listen(4776)
-
- const res = await axios.get('http://localhost:4776/todo/dishes')
-
- assert.strictEqual(res.data, 'The todo is: You have to do dishes')
- server.close()
- })
-
- it('lets you set no handler', async () => {
- const app = expressify(feathers())
- const data = { fromHandler: true }
-
- app
- .configure(rest(null))
- .use('/todo', {
- async get(id: Id) {
- return {
- description: `You have to do ${id}`
- }
- }
- })
- .use((_req: Request, res: Response) => res.json(data))
-
- const server = await app.listen(5775)
- const res = await axios.get('http://localhost:5775/todo-handler/dishes')
-
- assert.deepStrictEqual(res.data, data)
-
- server.close()
- })
- })
-
- describe('CRUD', () => {
- let app: express.Application
-
- before(async () => {
- app = expressify(feathers())
- .use(express.cors())
- .use(express.json())
- .configure(rest(express.formatter))
- .use('codes', {
- async get(id: Id) {
- return { id }
- },
-
- async create(data: any) {
- return data
- }
- })
- .use('/', new Service())
- .use('todo', new Service())
-
- app.hooks({
- setup: [
- async (context, next) => {
- assert.ok(context.app)
- await next()
- }
- ],
- teardown: [
- async (context, next) => {
- assert.ok(context.app)
- await next()
- }
- ]
- } as ApplicationHookMap)
-
- await app.listen(4777, () => app.use('tasks', new Service()))
- })
-
- after(() => app.teardown())
-
- restTests('Services', 'todo', 4777)
- restTests('Root Service', '/', 4777)
- restTests('Dynamic Services', 'tasks', 4777)
-
- describe('res.hook', () => {
- const convertHook = (hook: HookContext) => {
- const result: any = Object.assign({}, hook.toJSON())
-
- delete result.self
- delete result.service
- delete result.app
- delete result.error
-
- return result
- }
-
- it('sets the actual hook object in res.hook', async () => {
- const params = {
- route: {},
- query: { test: 'param' },
- provider: 'rest'
- }
-
- app.use(
- '/hook',
- {
- async get(id) {
- return {
- description: `You have to do ${id}`
- }
- }
- },
- function (_req: Request, res: Response, next: NextFunction) {
- res.data = convertHook(res.hook)
-
- next()
- }
- )
-
- app.service('hook').hooks({
- after(hook: HookContext) {
- hook.addedProperty = true
- }
- })
-
- const res = await axios.get('http://localhost:4777/hook/dishes?test=param')
- const paramsWithHeaders = {
- ...params,
- headers: res.data.params.headers
- }
-
- assert.deepStrictEqual(res.data, {
- id: 'dishes',
- params: paramsWithHeaders,
- arguments: ['dishes', paramsWithHeaders],
- type: 'around',
- method: 'get',
- path: 'hook',
- http: {},
- event: null,
- result: { description: 'You have to do dishes' },
- addedProperty: true
- })
- })
-
- it('can use hook.dispatch', async () => {
- app.use('/hook-dispatch', {
- async get() {
- return {}
- }
- })
-
- app.service('hook-dispatch').hooks({
- after(hook: HookContext) {
- hook.dispatch = {
- id: hook.id,
- fromDispatch: true
- }
- }
- })
-
- const res = await axios.get('http://localhost:4777/hook-dispatch/dishes')
- assert.deepStrictEqual(res.data, {
- id: 'dishes',
- fromDispatch: true
- })
- })
-
- it('allows to set statusCode in a hook', async () => {
- app.use('/hook-status', {
- async get() {
- return {}
- }
- })
-
- app.service('hook-status').hooks({
- after(hook: HookContext) {
- hook.http.status = 206
- }
- })
-
- const res = await axios.get('http://localhost:4777/hook-status/dishes')
-
- assert.strictEqual(res.status, 206)
- })
-
- it('allows to set response headers in a hook', async () => {
- app.use('/hook-headers', {
- async get() {
- return {}
- }
- })
-
- app.service('hook-headers').hooks({
- after(hook: HookContext) {
- hook.http.headers = { foo: 'first', bar: ['second', 'third'] }
- }
- })
-
- const res = await axios.get('http://localhost:4777/hook-headers/dishes')
-
- assert.strictEqual(res.headers.foo, 'first')
- assert.strictEqual(res.headers.bar, 'second, third')
- })
-
- it('sets the hook object in res.hook on error', async () => {
- const params = {
- route: {},
- query: {},
- provider: 'rest'
- }
-
- app.use('/hook-error', {
- async get() {
- throw new Error('I blew up')
- }
- })
- app.use(function (error: Error, _req: Request, res: Response, _next: NextFunction) {
- res.status(500)
- res.json({
- hook: convertHook(res.hook),
- error: {
- message: error.message
- }
- })
- })
-
- try {
- await axios('http://localhost:4777/hook-error/dishes')
- assert.fail('Should never get here')
- } catch (error: any) {
- const { data } = error.response
- const paramsWithHeaders = {
- ...params,
- headers: data.hook.params.headers
- }
- assert.deepStrictEqual(error.response.data, {
- hook: {
- id: 'dishes',
- params: paramsWithHeaders,
- arguments: ['dishes', paramsWithHeaders],
- type: 'around',
- event: null,
- method: 'get',
- path: 'hook-error',
- http: {}
- },
- error: { message: 'I blew up' }
- })
- }
- })
- })
- })
-
- describe('middleware', () => {
- it('sets service parameters and provider type', async () => {
- const service = {
- async get(_id: Id, params: Params) {
- return params
- }
- }
-
- const app = expressify(feathers())
- .use(function (req: Request, _res: Response, next: NextFunction) {
- req.feathers.test = 'Happy'
- next()
- })
- .configure(rest(express.formatter))
- .use('service', service)
- const server = await app.listen(4778)
-
- const res = await axios.get('http://localhost:4778/service/bla?some=param&another=thing')
- const expected = {
- headers: res.data.headers,
- test: 'Happy',
- provider: 'rest',
- route: {},
- query: {
- some: 'param',
- another: 'thing'
- }
- }
-
- assert.ok(res.status === 200, 'Got OK status code')
- assert.deepStrictEqual(res.data, expected, 'Got params object back')
- server.close()
- })
-
- it('Lets you configure your own middleware before the handler (#40)', async () => {
- const data = {
- description: 'Do dishes!',
- id: 'dishes'
- }
- const app = expressify(feathers())
-
- app
- .use(function defaultContentTypeMiddleware(req, _res, next) {
- req.headers['content-type'] = req.headers['content-type'] || 'application/json'
- next()
- })
- .use(express.json())
- .configure(rest(express.formatter))
- .use('/todo', {
- async create(data: any) {
- return data
- }
- })
-
- const server = await app.listen(4775)
- const res = await axios({
- url: 'http://localhost:4775/todo',
- method: 'post',
- data,
- headers: {
- 'content-type': ''
- }
- })
-
- assert.deepStrictEqual(res.data, data)
- server.close()
- })
-
- it('allows middleware before and after a service', async () => {
- const app = expressify(feathers())
-
- app
- .use(express.json())
- .configure(rest())
- .use(
- '/todo',
- function (req, _res, next) {
- req.body.before = ['before first']
- next()
- },
- function (req, _res, next) {
- req.body.before.push('before second')
- next()
- },
- {
- async create(data: any) {
- return data
- }
- },
- function (_req, res, next) {
- res.data.after = ['after first']
- next()
- },
- function (_req, res, next) {
- res.data.after.push('after second')
- next()
- }
- )
-
- const server = await app.listen(4776)
- const res = await axios.post('http://localhost:4776/todo', {
- text: 'Do dishes'
- })
-
- assert.deepStrictEqual(res.data, {
- text: 'Do dishes',
- before: ['before first', 'before second'],
- after: ['after first', 'after second']
- })
-
- server.close()
- })
-
- it('allows middleware arrays before and after a service', async () => {
- const app = expressify(feathers())
-
- app.use(express.json())
- app.configure(rest())
- app.use(
- '/todo',
- [
- function (req: Request, _res: Response, next: NextFunction) {
- req.body.before = ['before first']
- next()
- },
- function (req: Request, _res: Response, next: NextFunction) {
- req.body.before.push('before second')
- next()
- }
- ],
- {
- async create(data) {
- return data
- }
- },
- [
- function (_req: Request, res: Response, next: NextFunction) {
- res.data.after = ['after first']
- next()
- }
- ],
- function (_req: Request, res: Response, next: NextFunction) {
- res.data.after.push('after second')
- next()
- }
- )
-
- const server = await app.listen(4776)
- const res = await axios.post('http://localhost:4776/todo', {
- text: 'Do dishes'
- })
-
- assert.deepStrictEqual(res.data, {
- text: 'Do dishes',
- before: ['before first', 'before second'],
- after: ['after first', 'after second']
- })
- server.close()
- })
-
- it('allows an array of middleware without a service', async () => {
- const app = expressify(feathers())
- const middlewareArray = [
- function (_req: Request, res: Response, next: NextFunction) {
- res.data = ['first']
- next()
- },
- function (_req: Request, res: Response, next: NextFunction) {
- res.data.push('second')
- next()
- },
- function (req: Request, res: Response) {
- res.data.push(req.body.text)
- res.status(200).json(res.data)
- }
- ]
- app.use(express.json()).configure(rest()).use('/array-middleware', middlewareArray)
-
- const server = await app.listen(4776)
- const res = await axios.post('http://localhost:4776/array-middleware', {
- text: 'Do dishes'
- })
-
- assert.deepStrictEqual(res.data, ['first', 'second', 'Do dishes'])
- server.close()
- })
-
- it('formatter does nothing when there is no res.data', async () => {
- const data = { message: 'It worked' }
- const app = expressify(feathers()).use('/test', express.formatter, (_req: Request, res: Response) =>
- res.json(data)
- )
-
- const server = await app.listen(7988)
- const res = await axios.get('http://localhost:7988/test')
-
- assert.deepStrictEqual(res.data, data)
- server.close()
- })
- })
-
- describe('HTTP status codes', () => {
- let app: express.Application
- let server: Server
-
- before(async () => {
- app = expressify(feathers())
- .configure(rest(express.formatter))
- .use('todo', {
- async get(id: Id) {
- return {
- description: `You have to do ${id}`
- }
- },
-
- async patch() {
- throw new Error('Not implemented')
- },
-
- async find() {
- return null
- }
- })
-
- app.use(function (_req, res, next) {
- if (typeof res.data !== 'undefined') {
- next(new Error('Should never get here'))
- } else {
- next()
- }
- })
-
- // Error handler
- app.use(function (error: Error, _req: Request, res: Response, _next: NextFunction) {
- if (res.statusCode < 400) {
- res.status(500)
- }
-
- res.json({ message: error.message })
- })
-
- server = await app.listen(4780)
- })
-
- after((done) => server.close(done))
-
- it('throws a 405 for undefined service methods (#99)', async () => {
- const res = await axios.get('http://localhost:4780/todo/dishes')
-
- assert.ok(res.status === 200, 'Got OK status code for .get')
- assert.deepStrictEqual(
- res.data,
- {
- description: 'You have to do dishes'
- },
- 'Got expected object'
- )
-
- try {
- await axios.post('http://localhost:4780/todo')
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.ok(error.response.status === 405, 'Got 405 for .create')
- assert.deepStrictEqual(
- error.response.data,
- {
- message: 'Method `create` is not supported by this endpoint.'
- },
- 'Error serialized as expected'
- )
- }
- })
-
- it('throws a 404 for undefined route', async () => {
- try {
- await axios.get('http://localhost:4780/todo/foo/bar')
- assert.fail('Should never get here')
- } catch (error: any) {
- assert.ok(error.response.status === 404, 'Got Not Found code')
- }
- })
-
- it('empty response sets 204 status codes, does not run other middleware (#391)', async () => {
- const res = await axios.get('http://localhost:4780/todo')
-
- assert.ok(res.status === 204, 'Got empty status code')
- })
- })
-
- describe('route parameters', () => {
- let server: Server
- let app: express.Application
-
- before(async () => {
- app = expressify(feathers())
- .configure(rest())
- .use('/:appId/:id/todo', {
- async get(id: Id, params: Params) {
- if (params.query.error) {
- throw new BadRequest('Not good')
- }
-
- return {
- id,
- route: params.route
- }
- }
- })
- .use(errorHandler)
-
- server = await app.listen(6880)
- })
-
- after((done) => server.close(done))
-
- it('adds route params as `params.route` and allows id property (#76, #407)', async () => {
- const expected = {
- id: 'dishes',
- route: {
- appId: 'theApp',
- id: 'myId'
- }
- }
-
- const res = await axios.get(`http://localhost:6880/theApp/myId/todo/${expected.id}`)
-
- assert.ok(res.status === 200, 'Got OK status code')
- assert.deepStrictEqual(expected, res.data)
- })
-
- it('properly serializes error for nested routes (#1096)', async () => {
- try {
- await axios.get('http://localhost:6880/theApp/myId/todo/test?error=true')
- assert.fail('Should never het here')
- } catch (error: any) {
- const { response } = error
-
- assert.strictEqual(response.status, 400)
- assert.deepStrictEqual(response.data, {
- name: 'BadRequest',
- message: 'Not good',
- code: 400,
- className: 'bad-request'
- })
- }
- })
- })
-
- describe('Custom methods', () => {
- let server: Server
- let app: express.Application
-
- before(async () => {
- app = expressify(feathers())
- .use(express.json())
- .configure(rest())
- .use('/todo', new Service(), {
- methods: ['find', 'customMethod']
- })
- .use(errorHandler)
-
- server = await app.listen(4781)
- })
-
- after((done) => server.close(done))
-
- it('calls .customMethod with X-Service-Method header', async () => {
- const payload = { text: 'Do dishes' }
- const res = await axios.post('http://localhost:4781/todo', payload, {
- headers: {
- 'X-Service-Method': 'customMethod'
- }
- })
-
- assert.deepEqual(res.data, {
- data: payload,
- method: 'customMethod',
- provider: 'rest'
- })
- })
-
- it('throws MethodNotImplement for .setup, non option and default methods', async () => {
- const options: AxiosRequestConfig = {
- method: 'POST',
- url: 'http://localhost:4781/todo',
- data: { text: 'Do dishes' }
- }
- const testMethod = (name: string) => {
- return assert.rejects(
- () =>
- axios({
- ...options,
- headers: {
- 'X-Service-Method': name
- }
- }),
- (error: any) => {
- assert.deepEqual(error.response.data, {
- name: 'MethodNotAllowed',
- message: `Method \`${name}\` is not supported by this endpoint.`,
- code: 405,
- className: 'method-not-allowed'
- })
-
- return true
- }
- )
- }
-
- await testMethod('setup')
- await testMethod('internalMethod')
- await testMethod('nonExisting')
- await testMethod('create')
- await testMethod('find')
- })
- })
-})
diff --git a/packages/express/tsconfig.json b/packages/express/tsconfig.json
deleted file mode 100644
index 316fd41336..0000000000
--- a/packages/express/tsconfig.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "extends": "../../tsconfig",
- "include": [
- "src/**/*.ts"
- ],
- "compilerOptions": {
- "outDir": "lib"
- }
-}
diff --git a/packages/feathers/CHANGELOG.md b/packages/feathers/CHANGELOG.md
index b0dbdfbf32..4d3da51d28 100644
--- a/packages/feathers/CHANGELOG.md
+++ b/packages/feathers/CHANGELOG.md
@@ -3,6 +3,36 @@
All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+# [6.0.0-pre.3](https://github.com/feathersjs/feathers/compare/v6.0.0-pre.2...v6.0.0-pre.3) (2025-10-10)
+
+### Bug Fixes
+
+- Fix redirect URI encoding ([#3621](https://github.com/feathersjs/feathers/issues/3621)) ([4dbcce5](https://github.com/feathersjs/feathers/commit/4dbcce598d894846899417cd51820a70b00f22e0))
+
+# [6.0.0-pre.2](https://github.com/feathersjs/feathers/compare/v6.0.0-pre.1...v6.0.0-pre.2) (2025-09-04)
+
+### Bug Fixes
+
+- Add typesVersions for TypeScript compatibility ([87c181c](https://github.com/feathersjs/feathers/commit/87c181cf8d3bcd4f86d0caad41de83d220077ad8))
+
+# [6.0.0-pre.1](https://github.com/feathersjs/feathers/compare/v6.0.0-pre.0...v6.0.0-pre.1) (2025-09-03)
+
+### Bug Fixes
+
+- Add compatibility exports ([#3605](https://github.com/feathersjs/feathers/issues/3605)) ([3aed869](https://github.com/feathersjs/feathers/commit/3aed8696ca95fe4a4351c2d7e7f274ab66b50c09))
+- Add registerPublisher method to protected method list ([2c0664a](https://github.com/feathersjs/feathers/commit/2c0664acf97dca3bf7a2efaf3564f04c3de5842e))
+
+# [6.0.0-pre.0](https://github.com/feathersjs/feathers/compare/v5.0.34...v6.0.0-pre.0) (2025-08-30)
+
+### Bug Fixes
+
+- Make handling of async iterables consistent ([#3602](https://github.com/feathersjs/feathers/issues/3602)) ([a29ea3c](https://github.com/feathersjs/feathers/commit/a29ea3c89bf0fe07f0aec823ef3f3e33941f1aa3))
+
+### Features
+
+- SSE real-time events ([#3601](https://github.com/feathersjs/feathers/issues/3601)) ([fbfb75c](https://github.com/feathersjs/feathers/commit/fbfb75c5a2fde7ff785a71e787e746952b7a47b3))
+- V6 packages refactor ([#3596](https://github.com/feathersjs/feathers/issues/3596)) ([364aab5](https://github.com/feathersjs/feathers/commit/364aab563542fc9d6dd96c1f5f48b146727d7d1e))
+
## [5.0.34](https://github.com/feathersjs/feathers/compare/v5.0.33...v5.0.34) (2025-05-03)
### Bug Fixes
diff --git a/packages/feathers/LICENSE b/packages/feathers/LICENSE
index 7712f870f3..f9b502c69f 100644
--- a/packages/feathers/LICENSE
+++ b/packages/feathers/LICENSE
@@ -1,6 +1,6 @@
The MIT License (MIT)
-Copyright (c) 2024 Feathers Contributors
+Copyright (c) 2025 Feathers Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-
diff --git a/packages/feathers/README.md b/packages/feathers/README.md
index ecc774770b..0202868535 100644
--- a/packages/feathers/README.md
+++ b/packages/feathers/README.md
@@ -1,4 +1,4 @@
-
+
## The API and real-time application framework
@@ -6,9 +6,9 @@
[](https://www.npmjs.com/package/@feathersjs/feathers)
[](https://discord.gg/qa8kez8QBx)
-Feathers is a lightweight web-framework for creating APIs and real-time applications using TypeScript or JavaScript.
+Feathers is a full-stack framework for creating web APIs and real-time applications with TypeScript or JavaScript.
-Feathers can interact with any backend technology, supports many databases out of the box and works with any frontend technology like React, VueJS, Angular, React Native, Android or iOS.
+Feathers works with Node.js, Deno, Bun, Cloudflare Workers and standalone in the browser and can interact with any backend technology, supports many databases out of the box and works with any frontend like React, VueJS, Angular, React Native, Android or iOS.
## Getting started
@@ -26,6 +26,6 @@ To learn more about Feathers visit the website at [feathersjs.com](http://feathe
## License
-Copyright (c) 2024 [Feathers contributors](https://github.com/feathersjs/feathers/graphs/contributors)
+Copyright (c) 2025 [Feathers contributors](https://github.com/feathersjs/feathers/graphs/contributors)
Licensed under the [MIT license](LICENSE).
diff --git a/packages/feathers/fixtures/client.ts b/packages/feathers/fixtures/client.ts
new file mode 100644
index 0000000000..daa108184c
--- /dev/null
+++ b/packages/feathers/fixtures/client.ts
@@ -0,0 +1,110 @@
+import { describe, it } from 'vitest'
+import { strict as assert } from 'assert'
+import { verify } from './fixture'
+
+export interface Todo {
+ text: string
+ complete?: boolean
+ id?: number
+}
+
+export function clientTests(app: any, name: string) {
+ const getService = () => (name && typeof app.service === 'function' ? app.service(name) : app)
+
+ describe('Service base tests', () => {
+ it('.find', async () => {
+ const todos = await getService().find()
+
+ verify.find(todos)
+ })
+
+ it('.get and params passing', async () => {
+ const query = {
+ returnquery: 'true',
+ some: 'thing',
+ other: ['one', 'two'],
+ nested: { a: { b: 'object' } }
+ }
+
+ const todo = await getService().get('0', { query })
+
+ verify.get('0', todo)
+ assert.deepStrictEqual(todo.query, query)
+ })
+
+ it('.create', async () => {
+ const data = {
+ text: 'created todo',
+ complete: true
+ }
+ const todo = await getService().create(data)
+
+ verify.create(data, todo)
+ })
+
+ it('.create and created event', async () => {
+ const data = { text: 'created todo', complete: true }
+ const createPromise = new Promise((resolve) => {
+ getService().once('created', (current: Todo) => {
+ verify.create(data, current)
+ resolve(data)
+ })
+ })
+
+ await getService().create(data)
+ await createPromise
+ })
+
+ it('.update and updated event', async () => {
+ const updateData = {
+ text: 'updated todo',
+ complete: true
+ }
+ const updatePromise = new Promise((resolve) => {
+ getService().once('updated', (current: Todo) => {
+ verify.update('42', updateData, current)
+ resolve(updateData)
+ })
+ })
+
+ const todo = await getService().create({ text: 'todo to update', complete: false })
+ await getService().update(todo.id, updateData)
+ await updatePromise
+ })
+
+ it('.patch and patched event', async () => {
+ const patchData = { complete: true, text: 'patched to do' }
+ const patchPromise = new Promise((resolve) => {
+ getService().once('patched', (current: Todo) => {
+ verify.patch('42', patchData, current)
+ resolve(current)
+ })
+ })
+
+ const todo = await getService().create({ text: 'todo to patch', complete: false })
+ await getService().patch(todo.id, patchData)
+ await patchPromise
+ })
+
+ it('.remove and removed event', async () => {
+ const todo = await getService().create({ text: 'todo to remove', complete: false })
+ const removePromise = new Promise((resolve) => {
+ getService().once('removed', (current: Todo) => {
+ verify.remove('42', current)
+ resolve(current)
+ })
+ })
+
+ await getService().remove(todo.id)
+ await removePromise
+ })
+
+ it('.get with error', async () => {
+ const query = { error: true }
+
+ await assert.rejects(() => getService().get(0, { query }), {
+ message: 'Something for 0 went wrong'
+ })
+ })
+ })
+}
diff --git a/packages/tests/src/fixture.ts b/packages/feathers/fixtures/fixture.ts
similarity index 80%
rename from packages/tests/src/fixture.ts
rename to packages/feathers/fixtures/fixture.ts
index 2e7bbb3fbf..329eb6933c 100644
--- a/packages/tests/src/fixture.ts
+++ b/packages/feathers/fixtures/fixture.ts
@@ -1,4 +1,5 @@
-import assert from 'assert'
+import assert from 'node:assert'
+import { NotAcceptable, NotFound } from '../src/errors'
const clone = (data: any) => JSON.parse(JSON.stringify(data))
@@ -13,7 +14,7 @@ const findAllData = [
}
]
-export class Service {
+export class TestService {
events = ['log']
async find() {
@@ -21,19 +22,37 @@ export class Service {
}
async get(name: string, params: any) {
- if (params.query.error) {
+ const { query = {}, headers } = params
+
+ if (query.error) {
throw new Error(`Something for ${name} went wrong`)
}
- if (params.query.runtimeError) {
+ if (query.runtimeError) {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
thingThatDoesNotExist() // eslint-disable-line
}
+ if (name === 'nocontent') {
+ return null
+ }
+
+ if (name === 'notfound') {
+ throw new NotFound('Not found')
+ }
+
+ if (name === 'notacceptable') {
+ throw new NotAcceptable('This is a Feathers error', {
+ testData: true
+ })
+ }
+
return Promise.resolve({
id: name,
- description: `You have to do ${name}!`
+ description: `You have to do ${name}!`,
+ ...(query.returnquery ? { query } : {}),
+ ...(query.returnheaders ? { headers } : {})
})
}
diff --git a/packages/feathers/fixtures/index.ts b/packages/feathers/fixtures/index.ts
new file mode 100644
index 0000000000..23e06851c0
--- /dev/null
+++ b/packages/feathers/fixtures/index.ts
@@ -0,0 +1,78 @@
+import { createServerAdapter } from '@whatwg-node/server'
+import { createServer } from 'node:http'
+import { TestService } from './fixture.js'
+
+import { feathers, Application, Params } from '../src/index.js'
+import { createHandler, SseService } from '../src/http/index.js'
+
+export * from './client.js'
+export * from './rest.js'
+export * from './fixture.js'
+
+export class ResponseTestService {
+ async find() {
+ return new Response('Plain text', {
+ headers: {
+ 'Content-Type': 'text/plain',
+ 'X-Custom-Header': 'test'
+ }
+ })
+ }
+
+ async get(id: string) {
+ const generator = async function* () {
+ for (let i = 1; i <= 5; i++) {
+ yield { message: `Hello ${id} ${i}` }
+ await new Promise((resolve) => setTimeout(resolve, 50))
+ }
+ }
+
+ return generator()
+ }
+
+ async options(_params: Params) {
+ return new Response(null, {
+ status: 200,
+ headers: {
+ 'X-Feathers': 'true',
+ 'Access-Control-Allow-Origin': 'https://example.com',
+ 'Access-Control-Allow-Headers': 'Authorization, X-Service-Method'
+ }
+ })
+ }
+}
+
+export type TestServiceTypes = {
+ todos: TestService
+ test: ResponseTestService
+ sse: SseService
+}
+
+export type TestApplication = Application
+
+export function getApp(): TestApplication {
+ const app: TestApplication = feathers()
+
+ app.use('todos', new TestService(), {
+ methods: ['find', 'get', 'create', 'update', 'patch', 'remove', 'customMethod']
+ })
+ app.use('test', new ResponseTestService())
+ app.use('sse', new SseService())
+
+ return app
+}
+
+export async function createTestServer(port: number, app: TestApplication) {
+ const handler = createHandler(app)
+ // You can create your Node server instance by using our adapter
+ const nodeServer = createServer(createServerAdapter(handler))
+
+ await new Promise((resolve) => {
+ // Then start listening on some port
+ nodeServer.listen(port, () => resolve())
+ })
+
+ await app.setup(nodeServer)
+
+ return nodeServer
+}
diff --git a/packages/feathers/fixtures/rest.ts b/packages/feathers/fixtures/rest.ts
new file mode 100644
index 0000000000..9e65221bf8
--- /dev/null
+++ b/packages/feathers/fixtures/rest.ts
@@ -0,0 +1,136 @@
+import { describe, it } from 'vitest'
+import assert from 'assert'
+
+import { verify } from './fixture'
+
+export function restTests(description: string, name: string, port: number) {
+ describe(description, () => {
+ it('GET .find', async () => {
+ const response = await fetch(`http://localhost:${port}/${name}`)
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.find(data)
+ })
+
+ it('GET .get', async () => {
+ const response = await fetch(`http://localhost:${port}/${name}/dishes`)
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.get('dishes', data)
+ })
+
+ it('POST .create', async () => {
+ const original = {
+ description: 'POST .create'
+ }
+
+ const response = await fetch(`http://localhost:${port}/${name}`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(original)
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 201, 'Got CREATED status code')
+ verify.create(original, data)
+ })
+
+ it('PUT .update', async () => {
+ const original = {
+ description: 'PUT .update'
+ }
+
+ const response = await fetch(`http://localhost:${port}/${name}/544`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(original)
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.update('544', original, data)
+ })
+
+ it('PUT .update many', async () => {
+ const original = {
+ description: 'PUT .update',
+ many: true
+ }
+
+ const response = await fetch(`http://localhost:${port}/${name}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(original)
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.update(null, original, data)
+ })
+
+ it('PATCH .patch', async () => {
+ const original = {
+ description: 'PATCH .patch'
+ }
+
+ const response = await fetch(`http://localhost:${port}/${name}/544`, {
+ method: 'PATCH',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(original)
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.patch('544', original, data)
+ })
+
+ it('PATCH .patch many', async () => {
+ const original = {
+ description: 'PATCH .patch',
+ many: true
+ }
+
+ const response = await fetch(`http://localhost:${port}/${name}`, {
+ method: 'PATCH',
+ headers: {
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(original)
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.patch(null, original, data)
+ })
+
+ it('DELETE .remove', async () => {
+ const response = await fetch(`http://localhost:${port}/${name}/233`, {
+ method: 'DELETE'
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.remove('233', data)
+ })
+
+ it('DELETE .remove many', async () => {
+ const response = await fetch(`http://localhost:${port}/${name}`, {
+ method: 'DELETE'
+ })
+ const data = await response.json()
+
+ assert.ok(response.status === 200, 'Got OK status code')
+ verify.remove(null, data)
+ })
+ })
+}
diff --git a/packages/feathers/package.json b/packages/feathers/package.json
index 370a290a76..a7995b5c37 100644
--- a/packages/feathers/package.json
+++ b/packages/feathers/package.json
@@ -1,8 +1,8 @@
{
- "name": "@feathersjs/feathers",
- "description": "A framework for real-time applications and REST API with JavaScript and TypeScript",
- "version": "5.0.34",
- "homepage": "http://feathersjs.com",
+ "name": "feathers",
+ "description": "The API and real-time application framework",
+ "version": "6.0.0-pre.3",
+ "homepage": "https://feathersjs.com",
"repository": {
"type": "git",
"url": "git://github.com/feathersjs/feathers.git",
@@ -11,11 +11,40 @@
"keywords": [
"feathers",
"REST",
- "socket.io",
- "realtime"
+ "realtime",
+ "framework",
+ "API"
],
- "main": "lib/",
- "types": "lib/",
+ "type": "module",
+ "main": "lib/index.js",
+ "types": "lib/index.d.ts",
+ "exports": {
+ ".": "./lib/index.js",
+ "./hooks": "./lib/hooks/index.js",
+ "./commons": "./lib/commons.js",
+ "./errors": "./lib/errors.js",
+ "./client": "./lib/client/index.js",
+ "./http": "./lib/http/index.js"
+ },
+ "typesVersions": {
+ "*": {
+ "errors": [
+ "./lib/errors.d.ts"
+ ],
+ "hooks": [
+ "./lib/hooks/index.d.ts"
+ ],
+ "commons": [
+ "./lib/commons.d.ts"
+ ],
+ "client": [
+ "./lib/client/index.d.ts"
+ ],
+ "http": [
+ "./lib/http/index.d.ts"
+ ]
+ }
+ },
"author": {
"name": "Feathers contributors",
"email": "hello@feathersjs.com",
@@ -37,9 +66,7 @@
"LICENSE",
"README.md",
"src/**",
- "lib/**",
- "*.d.ts",
- "*.js"
+ "lib/**"
],
"scripts": {
"write-version": "node -e \"console.log('export default \\'' + require('./package.json').version + '\\'')\" > src/version.ts",
@@ -47,28 +74,28 @@
"prepublish": "npm run compile",
"version": "npm run write-version",
"publish": "npm run reset-version",
- "pack": "npm pack --pack-destination ../generators/test/build",
- "compile": "shx rm -rf lib/ && tsc && npm run pack",
- "test": "mocha --config ../../.mocharc.json --recursive test/"
+ "compile": "shx rm -rf lib/ && tsc",
+ "dev": "vitest",
+ "test": "vitest run --coverage"
},
"engines": {
- "node": ">= 12"
+ "node": ">= 20"
},
"publishConfig": {
"access": "public"
},
"dependencies": {
- "@feathersjs/commons": "^5.0.34",
- "@feathersjs/hooks": "^0.9.0",
- "events": "^3.3.0"
+ "@types/qs": "^6.14.0",
+ "events": "^3.3.0",
+ "qs": "^6.14.0"
},
"devDependencies": {
- "@types/mocha": "^10.0.10",
"@types/node": "^24.1.0",
- "mocha": "^11.7.1",
+ "@vitest/coverage-v8": "^3.2.4",
+ "@whatwg-node/server": "^0.10.12",
"shx": "^0.4.0",
- "ts-node": "^10.9.2",
- "typescript": "^5.9.2"
+ "typescript": "^5.8.0",
+ "vitest": "^3.2.4"
},
"gitHead": "90caf635aec850550b9d37bea2762af959d9e8d5"
}
diff --git a/packages/feathers/test/application.test.ts b/packages/feathers/src/application.test.ts
similarity index 86%
rename from packages/feathers/test/application.test.ts
rename to packages/feathers/src/application.test.ts
index ea5a937741..337508552c 100644
--- a/packages/feathers/test/application.test.ts
+++ b/packages/feathers/src/application.test.ts
@@ -1,6 +1,7 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { describe, it } from 'vitest'
import assert from 'assert'
-import { feathers, Feathers, getServiceOptions, Id, version } from '../src'
+import { feathers, Feathers, getServiceOptions, Id, version } from '../src/index.js'
describe('Feathers application', () => {
it('initializes', () => {
@@ -16,16 +17,19 @@ describe('Feathers application', () => {
assert.ok(app.version > '5.0.0')
})
- it('is an event emitter', (done) => {
+ it('is an event emitter', async () => {
const app = feathers()
const original = { hello: 'world' }
- app.on('test', (data: any) => {
- assert.deepStrictEqual(original, data)
- done()
+ const promise = new Promise((resolve) => {
+ app.on('test', (data: any) => {
+ assert.deepStrictEqual(original, data)
+ resolve()
+ })
})
app.emit('test', original)
+ await promise
})
it('uses .defaultService if available', async () => {
@@ -55,10 +59,12 @@ describe('Feathers application', () => {
})
})
- it('additionally passes `app` as .configure parameter (#558)', (done) => {
- feathers().configure(function (app) {
- assert.strictEqual(this, app)
- done()
+ it('additionally passes `app` as .configure parameter (#558)', async () => {
+ await new Promise((resolve) => {
+ feathers().configure(function (app) {
+ assert.strictEqual(this, app)
+ resolve()
+ })
})
})
@@ -164,6 +170,15 @@ describe('Feathers application', () => {
message: "'teardown' on service 'dummy' is not allowed as a custom method name"
}
)
+ assert.throws(
+ () =>
+ feathers().use('/dummy', dummyService, {
+ methods: ['create', 'registerPublisher']
+ }),
+ {
+ message: "'registerPublisher' on service 'dummy' is not allowed as a custom method name"
+ }
+ )
})
it('can register service with no external methods', async () => {
@@ -190,7 +205,7 @@ describe('Feathers application', () => {
assert.deepStrictEqual(result, { id: 'test' })
})
- it('services can be re-used (#566)', (done) => {
+ it('services can be re-used (#566)', async () => {
const service = {
async create(data: any) {
return data
@@ -199,35 +214,28 @@ describe('Feathers application', () => {
const app1 = feathers<{ dummy: typeof service; testing: any }>()
const app2 = feathers<{ dummy: typeof service; testing: any }>()
- app2.use('dummy', {
- async create(data: any) {
- return data
- }
- })
+ app1.use('dummy', service)
+ app2.use('dummy', service)
const dummy = app2.service('dummy')
dummy.hooks({
before: {
create: [
- (hook) => {
- hook.data.fromHook = true
+ async (context: any) => {
+ context.data.fromHook = true
+ return context
}
]
}
})
- dummy.on('created', (data: any) => {
- assert.deepStrictEqual(data, {
- message: 'Hi',
- fromHook: true
- })
- done()
- })
-
- app1.use('testing', app2.service('dummy'))
+ const result = await dummy.create({ message: 'Hello' })
- app1.service('testing').create({ message: 'Hi' })
+ assert.deepStrictEqual(result, {
+ message: 'Hello',
+ fromHook: true
+ })
})
it('async hooks run before regular hooks', async () => {
@@ -406,7 +414,7 @@ describe('Feathers application', () => {
assert.strictEqual(teardownCount, 2)
})
- it('registering app.setup but while still pending will be set up', (done) => {
+ it('registering app.setup but while still pending will be set up', async () => {
const app = feathers()
app.setup()
@@ -416,7 +424,6 @@ describe('Feathers application', () => {
assert.ok((app as any)._isSetup)
assert.strictEqual(appRef, app)
assert.strictEqual(path, 'dummy')
- done()
}
})
})
@@ -507,7 +514,7 @@ describe('Feathers application', () => {
})
describe('sub apps', () => {
- it('re-registers sub-app services with prefix', (done) => {
+ it('re-registers sub-app services with prefix', async () => {
const app = feathers()
const subApp = feathers()
@@ -535,34 +542,25 @@ describe('Feathers application', () => {
app.use('/api/', subApp)
- app.service('/api/service2').once('created', (data: any) => {
- assert.deepStrictEqual(data, {
- message: 'This is a test'
- })
-
- subApp.service('service2').once('created', (data: any) => {
- assert.deepStrictEqual(data, {
- message: 'This is another test'
- })
+ const result1 = await app.service('/api/service1').get(10)
+ assert.strictEqual(result1.name, 'service1')
- done()
- })
+ const result2 = await app.service('/api/service2').get(1)
+ assert.strictEqual(result2.name, 'service2')
- app.service('api/service2').create({
- message: 'This is another test'
- })
+ const result3 = await subApp.service('service2').create({
+ message: 'This is a test'
+ })
+ assert.deepStrictEqual(result3, {
+ message: 'This is a test'
})
- ;(async () => {
- let data = await app.service('/api/service1').get(10)
- assert.strictEqual(data.name, 'service1')
-
- data = await app.service('/api/service2').get(1)
- assert.strictEqual(data.name, 'service2')
- await subApp.service('service2').create({
- message: 'This is a test'
- })
- })()
+ const result4 = await app.service('/api/service2').create({
+ message: 'This is another test'
+ })
+ assert.deepStrictEqual(result4, {
+ message: 'This is another test'
+ })
})
})
})
diff --git a/packages/feathers/src/application.ts b/packages/feathers/src/application.ts
index 6abf661b1e..1033284c84 100644
--- a/packages/feathers/src/application.ts
+++ b/packages/feathers/src/application.ts
@@ -1,11 +1,14 @@
-import version from './version'
import { EventEmitter } from 'events'
-import { stripSlashes, createDebug } from '@feathersjs/commons'
-import { HOOKS, hooks, middleware } from '@feathersjs/hooks'
-import { eventHook, eventMixin } from './events'
-import { hookMixin } from './hooks'
-import { wrapService, getServiceOptions, protectedMethods } from './service'
-import {
+import { HOOKS, hooks, middleware } from './hooks/index.js'
+
+import { stripSlashes } from './commons.js'
+import { createDebug } from './debug.js'
+
+import version from './version.js'
+import { eventHook, eventMixin } from './events.js'
+import { hookMixin } from './hooks.js'
+import { wrapService, getServiceOptions, protectedMethods, defaultServiceEvents } from './service.js'
+import type {
FeathersApplication,
ServiceMixin,
Service,
@@ -14,10 +17,15 @@ import {
Application,
FeathersService,
ApplicationHookOptions
-} from './declarations'
-import { enableHooks } from './hooks'
+} from './declarations.js'
+import { enableHooks } from './hooks.js'
+import { Router } from './router.js'
+import { Channel } from './channel/base.js'
+import { CombinedChannel } from './channel/combined.js'
+import { channelServiceMixin, Event, Publisher, PUBLISHERS, ALL_EVENTS, CHANNELS } from './channel/mixin.js'
const debug = createDebug('@feathersjs/feathers')
+const channelDebug = createDebug('@feathersjs/transport-commons/channels')
export class Feathers
extends EventEmitter
@@ -27,10 +35,15 @@ export class Feathers
settings: Settings = {} as Settings
mixins: ServiceMixin>[] = [hookMixin, eventMixin]
version: string = version
+ routes: Router = new Router()
_isSetup = false
protected registerHooks: (this: any, allHooks: any) => any
+ // Channel-related properties
+ public [CHANNELS]: { [key: string]: Channel } = {}
+ public [PUBLISHERS]: { [ALL_EVENTS]?: Publisher; [key: string]: Publisher } = {}
+
constructor() {
super()
this.registerHooks = enableHooks(this)
@@ -39,6 +52,67 @@ export class Feathers
})
}
+ get channels(): string[] {
+ return Object.keys(this[CHANNELS])
+ }
+
+ channel(...names: string[]): Channel {
+ channelDebug('Returning channels', names)
+
+ if (names.length === 0) {
+ throw new Error('app.channel needs at least one channel name')
+ }
+
+ if (names.length === 1) {
+ const [name] = names
+
+ if (Array.isArray(name)) {
+ return this.channel(...name)
+ }
+
+ if (!this[CHANNELS][name]) {
+ const channel = new Channel()
+
+ channel.once('empty', () => {
+ channel.removeAllListeners()
+ delete this[CHANNELS][name]
+ })
+
+ this[CHANNELS][name] = channel
+ }
+
+ return this[CHANNELS][name]
+ }
+
+ const channels = names.map((name) => this.channel(name))
+
+ return new CombinedChannel(channels)
+ }
+
+ publish(event: Event | Publisher, publisher?: Publisher): this {
+ return this.registerPublisher(event, publisher)
+ }
+
+ registerPublisher(event: Event | Publisher, publisher?: Publisher): this {
+ channelDebug('Registering publisher', event)
+
+ if (!publisher && typeof event === 'function') {
+ publisher = event
+ event = ALL_EVENTS
+ }
+
+ const { serviceEvents = defaultServiceEvents } = getServiceOptions(this) || {}
+
+ if (event !== ALL_EVENTS && !serviceEvents.includes(event as string)) {
+ throw new Error(`'${event.toString()}' is not a valid service event`)
+ }
+
+ const publishers = this[PUBLISHERS]
+ publishers[event as string] = publisher!
+
+ return this
+ }
+
get(name: L): Settings[L] {
return this.settings[name]
}
@@ -72,6 +146,23 @@ export class Feathers
return current as any
}
+ lookup(path: string) {
+ const result = this.routes.lookup(path)
+
+ if (result === null) {
+ return null
+ }
+
+ const {
+ params: colonParams,
+ data: { service, params: dataParams }
+ } = result
+
+ const params = dataParams ? { ...dataParams, ...colonParams } : colonParams
+
+ return { service, params }
+ }
+
protected _setup() {
this._isSetup = true
@@ -165,6 +256,10 @@ export class Feathers
const protoService = wrapService(location, service, options as ServiceOptions)
const serviceOptions = getServiceOptions(protoService)
+ const routerParams = {
+ service: protoService,
+ params: serviceOptions.routeParams || {}
+ }
for (const name of protectedMethods) {
if (serviceOptions.methods.includes(name)) {
@@ -177,6 +272,11 @@ export class Feathers
// Add all the mixins
this.mixins.forEach((fn) => fn.call(this, protoService, location, serviceOptions))
+ // Add channel publishing functionality to the service
+ channelServiceMixin(this as any)(protoService, location, serviceOptions)
+
+ this.routes.insert(path, routerParams)
+ this.routes.insert(`${path}/:__id`, routerParams)
this.services[location] = protoService
// If we ran setup already, set this service up explicitly, this will not `await`
@@ -200,6 +300,9 @@ export class Feathers
delete this.services[path]
+ this.routes.remove(path)
+ this.routes.remove(`${path}/:__id`)
+
return service as any
}
diff --git a/packages/transport-commons/src/channels/channel/base.ts b/packages/feathers/src/channel/base.ts
similarity index 95%
rename from packages/transport-commons/src/channels/channel/base.ts
rename to packages/feathers/src/channel/base.ts
index 4717393880..1c2f2fb4e2 100644
--- a/packages/transport-commons/src/channels/channel/base.ts
+++ b/packages/feathers/src/channel/base.ts
@@ -1,5 +1,5 @@
import { EventEmitter } from 'events'
-import { RealTimeConnection } from '@feathersjs/feathers'
+import { RealTimeConnection } from '../declarations.js'
export class Channel extends EventEmitter {
connections: RealTimeConnection[]
diff --git a/packages/transport-commons/test/channels/channel.test.ts b/packages/feathers/src/channel/channel.test.ts
similarity index 93%
rename from packages/transport-commons/test/channels/channel.test.ts
rename to packages/feathers/src/channel/channel.test.ts
index 2e9502d9db..4e95d450d6 100644
--- a/packages/transport-commons/test/channels/channel.test.ts
+++ b/packages/feathers/src/channel/channel.test.ts
@@ -1,17 +1,15 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
+import { describe, it, beforeEach } from 'vitest'
import assert from 'assert'
-import { feathers, Application, RealTimeConnection } from '@feathersjs/feathers'
-import { channels, keys } from '../../src/channels'
-import { Channel } from '../../src/channels/channel/base'
-import { CombinedChannel } from '../../src/channels/channel/combined'
-
-const { CHANNELS } = keys
+import { feathers, Application, RealTimeConnection } from '../index.js'
+import { Channel } from './base.js'
+import { CombinedChannel } from './combined.js'
+import { CHANNELS } from './mixin.js'
describe('app.channel', () => {
let app: Application
beforeEach(() => {
- app = feathers().configure(channels())
+ app = feathers()
})
describe('base channels', () => {
@@ -115,16 +113,20 @@ describe('app.channel', () => {
})
})
- it('empty', (done) => {
+ it('empty', async () => {
const channel = app.channel('test')
const c1 = { id: 1 }
const c2 = { id: 2 }
- channel.once('empty', done)
+ const promise = new Promise((resolve) => {
+ channel.once('empty', resolve)
+ })
channel.join(c1, c2)
channel.leave(c1)
channel.leave(c2)
+
+ await promise
})
it('removes an empty channel', () => {
diff --git a/packages/transport-commons/src/channels/channel/combined.ts b/packages/feathers/src/channel/combined.ts
similarity index 93%
rename from packages/transport-commons/src/channels/channel/combined.ts
rename to packages/feathers/src/channel/combined.ts
index c6723f61d9..2b6bf0f178 100644
--- a/packages/transport-commons/src/channels/channel/combined.ts
+++ b/packages/feathers/src/channel/combined.ts
@@ -1,5 +1,5 @@
-import { RealTimeConnection } from '@feathersjs/feathers'
-import { Channel } from './base'
+import { RealTimeConnection } from '../declarations.js'
+import { Channel } from './base.js'
function collectConnections(children: Channel[]) {
const mappings = new WeakMap()
diff --git a/packages/feathers/src/channel/dispatch.test.ts b/packages/feathers/src/channel/dispatch.test.ts
new file mode 100644
index 0000000000..ad3b3832a7
--- /dev/null
+++ b/packages/feathers/src/channel/dispatch.test.ts
@@ -0,0 +1,264 @@
+import { describe, it, beforeEach } from 'vitest'
+import assert from 'assert'
+import { feathers, Application, HookContext } from '../index.js'
+import { Channel } from './base.js'
+import { CombinedChannel } from './combined.js'
+
+class TestService {
+ events = ['foo']
+
+ async create(payload: any) {
+ return payload
+ }
+}
+
+describe('app.publish', () => {
+ let app: Application
+
+ beforeEach(() => {
+ app = feathers()
+ })
+
+ it('throws an error if service does not send the event', () => {
+ try {
+ app.use('/test', {
+ create(data: any) {
+ return Promise.resolve(data)
+ }
+ })
+
+ app.service('test').registerPublisher('created', function () {})
+ app.service('test').registerPublisher('bla', function () {})
+ assert.ok(false, 'Should never get here')
+ } catch (e: any) {
+ assert.strictEqual(e.message, "'bla' is not a valid service event")
+ }
+ })
+
+ describe('registration and `dispatch` event', () => {
+ const c1 = { id: 1, test: true }
+ const c2 = { id: 2, test: true }
+ const data = { message: 'This is a test' }
+
+ beforeEach(() => {
+ app.use('/test', new TestService())
+ })
+
+ it('error in publisher is handled gracefully (#1707)', async () => {
+ app.service('test').publish('created', () => {
+ throw new Error('Something went wrong')
+ })
+
+ try {
+ await app.service('test').create({ message: 'something' })
+ } catch (_error: any) {
+ assert.fail('Should never get here')
+ }
+ })
+
+ it('simple event registration and dispatching', async () => {
+ app.channel('testing').join(c1)
+
+ app.service('test').registerPublisher('created', () => app.channel('testing'))
+
+ const publishPromise = new Promise((resolve, reject) => {
+ app.once('publish', (event: string, channel: Channel, hook: HookContext) => {
+ try {
+ assert.strictEqual(event, 'created')
+ assert.strictEqual(hook.path, 'test')
+ assert.deepStrictEqual(hook.result, data)
+ assert.deepStrictEqual(channel.connections, [c1])
+ resolve()
+ } catch (error: any) {
+ reject(error)
+ }
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('app and global level dispatching and precedence', async () => {
+ app.channel('testing').join(c1)
+ app.channel('other').join(c2)
+
+ app.registerPublisher('created', () => app.channel('testing'))
+ app.registerPublisher(() => app.channel('other'))
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (_event: string, channel: Channel) => {
+ assert.ok(channel.connections.indexOf(c1) !== -1)
+ resolve()
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('promise event dispatching', async () => {
+ app.channel('testing').join(c1)
+ app.channel('othertest').join(c2)
+
+ app
+ .service('test')
+ .registerPublisher(
+ 'created',
+ () => new Promise((resolve) => setTimeout(() => resolve(app.channel('testing')), 50))
+ )
+ app
+ .service('test')
+ .registerPublisher(
+ 'created',
+ () => new Promise((resolve) => setTimeout(() => resolve(app.channel('testing', 'othertest')), 100))
+ )
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (_event: string, channel: Channel, hook: HookContext) => {
+ assert.deepStrictEqual(hook.result, data)
+ assert.deepStrictEqual(channel.connections, [c1, c2])
+ resolve()
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('custom event dispatching', async () => {
+ const eventData = { testing: true }
+
+ app.channel('testing').join(c1)
+ app.channel('othertest').join(c2)
+
+ app.service('test').registerPublisher('foo', () => app.channel('testing'))
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (event: string, channel: Channel, hook: HookContext) => {
+ assert.strictEqual(event, 'foo')
+ assert.deepStrictEqual(hook, {
+ app,
+ path: 'test',
+ service: app.service('test'),
+ result: eventData
+ })
+ assert.deepStrictEqual(channel.connections, [c1])
+ resolve()
+ })
+ })
+
+ app.service('test').emit('foo', eventData)
+ await publishPromise
+ })
+
+ it('does not sent `dispatch` event if there are no dispatchers', async () => {
+ const publishPromise = new Promise((resolve, reject) => {
+ app.once('publish', () => reject(new Error('Should never get here')))
+
+ // Set a timeout to resolve the promise if no publish event occurs
+ setTimeout(resolve, 100)
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('does not send `dispatch` event if there are no connections', async () => {
+ app.service('test').registerPublisher('created', () => app.channel('dummy'))
+
+ const publishPromise = new Promise((resolve, reject) => {
+ app.once('publish', () => reject(new Error('Should never get here')))
+
+ // Set a timeout to resolve the promise if no publish event occurs
+ setTimeout(resolve, 100)
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('dispatcher returning an array of channels', async () => {
+ app.channel('testing').join(c1)
+ app.channel('othertest').join(c2)
+
+ app
+ .service('test')
+ .registerPublisher('created', () => [app.channel('testing'), app.channel('othertest')])
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (_event: string, channel: Channel, hook: HookContext) => {
+ assert.deepStrictEqual(hook.result, data)
+ assert.deepStrictEqual(channel.connections, [c1, c2])
+ resolve()
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('dispatcher can send data', async () => {
+ const c1data = { channel: 'testing' }
+
+ app.channel('testing').join(c1)
+ app.channel('othertest').join(c2)
+
+ app
+ .service('test')
+ .registerPublisher('created', () => [app.channel('testing').send(c1data), app.channel('othertest')])
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (_event: string, channel: CombinedChannel, hook: HookContext) => {
+ assert.deepStrictEqual(hook.result, data)
+ assert.deepStrictEqual(channel.dataFor(c1), c1data)
+ assert.ok(channel.dataFor(c2) === null)
+ assert.deepStrictEqual(channel.connections, [c1, c2])
+ resolve()
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('publisher precedence and preventing publishing', async () => {
+ app.channel('test').join(c1)
+
+ app.registerPublisher(() => app.channel('test'))
+ app.service('test').registerPublisher('created', (): null => null)
+
+ const publishPromise = new Promise((resolve, reject) => {
+ app.once('publish', () => reject(new Error('Should never get here')))
+
+ // Set a timeout to resolve the promise if no publish event occurs
+ setTimeout(resolve, 100)
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+
+ it('data of first channel has precedence', async () => {
+ const sendData = { test: true }
+
+ app.channel('testing').join(c1)
+ app.channel('othertest').join(c1)
+
+ app.service('test').registerPublisher('created', () => {
+ return [app.channel('testing'), app.channel('othertest').send(sendData)]
+ })
+
+ const publishPromise = new Promise((resolve) => {
+ app.once('publish', (_event: string, channel: CombinedChannel) => {
+ assert.strictEqual(channel.dataFor(c1), null)
+ assert.deepStrictEqual(channel.connections, [c1])
+ resolve()
+ })
+ })
+
+ await app.service('test').create(data)
+ await publishPromise
+ })
+ })
+})
diff --git a/packages/feathers/src/channel/mixin.ts b/packages/feathers/src/channel/mixin.ts
new file mode 100644
index 0000000000..24fa383275
--- /dev/null
+++ b/packages/feathers/src/channel/mixin.ts
@@ -0,0 +1,102 @@
+import { createDebug } from '../debug.js'
+import type { ServiceOptions, HookContext, Application } from '../declarations.js'
+import { Channel } from './base.js'
+import { CombinedChannel } from './combined.js'
+
+const debug = createDebug('@feathersjs/transport-commons/channels')
+
+const CHANNELS = Symbol.for('@feathersjs/transport-commons/channels')
+const PUBLISHERS = Symbol.for('@feathersjs/transport-commons/publishers')
+const ALL_EVENTS = Symbol.for('@feathersjs/transport-commons/all-events')
+
+function flattenDeep(arr: Array): T[] {
+ return arr.reduce((flat: T[], toFlatten: T | T[]) => {
+ return flat.concat(Array.isArray(toFlatten) ? flattenDeep(toFlatten) : toFlatten)
+ }, [])
+}
+
+export type Event = string | typeof ALL_EVENTS
+
+export type Publisher = (
+ data: T,
+ context: HookContext
+) => Channel | Channel[] | void | Promise
+
+export function channelServiceMixin(app: Application) {
+ return (service: any, path: string, serviceOptions: ServiceOptions) => {
+ const { serviceEvents } = serviceOptions
+
+ if (typeof service.publish === 'function') {
+ return
+ }
+
+ // Add publish methods to service
+ service[PUBLISHERS] = {}
+ service.publish = function (event: Event | Publisher, publisher?: Publisher) {
+ return (service as any).registerPublisher(event, publisher)
+ }
+ service.registerPublisher = function (event: Event | Publisher, publisher?: Publisher) {
+ debug('Registering service publisher', event)
+
+ if (!publisher && typeof event === 'function') {
+ publisher = event
+ event = ALL_EVENTS
+ }
+
+ if (event !== ALL_EVENTS && !serviceEvents!.includes(event as string)) {
+ throw new Error(`'${event.toString()}' is not a valid service event`)
+ }
+
+ const publishers = (service as any)[PUBLISHERS]
+ publishers[event as string] = publisher!
+
+ return service
+ }
+
+ serviceEvents!.forEach((event: string) => {
+ service.on(event, (data: unknown, hook: HookContext) => {
+ if (!hook) {
+ hook = { path, service, app, result: data } as HookContext
+ }
+
+ debug('Publishing event', event, hook.path)
+
+ const logError = (error: any) => debug(`Error in '${hook.path} ${event}' publisher`, error)
+ const servicePublishers = (service as any)[PUBLISHERS]
+ const appPublishers = (app as any)[PUBLISHERS]
+
+ const publisher =
+ servicePublishers[event] ||
+ servicePublishers[ALL_EVENTS] ||
+ appPublishers[event] ||
+ appPublishers[ALL_EVENTS] ||
+ (() => {})
+
+ try {
+ Promise.resolve(publisher(data, hook))
+ .then((result: any) => {
+ if (!result) {
+ return
+ }
+
+ const results = Array.isArray(result)
+ ? flattenDeep(result).filter(Boolean)
+ : ([result] as Channel[])
+ const channel = new CombinedChannel(results)
+
+ if (channel && channel.length > 0) {
+ app.emit('publish', event, channel, hook, data)
+ } else {
+ debug('No connections to publish to')
+ }
+ })
+ .catch(logError)
+ } catch (error: any) {
+ logError(error)
+ }
+ })
+ })
+ }
+}
+
+export { PUBLISHERS, ALL_EVENTS, CHANNELS }
diff --git a/packages/feathers/src/client/fetch.test.ts b/packages/feathers/src/client/fetch.test.ts
new file mode 100644
index 0000000000..25008f1363
--- /dev/null
+++ b/packages/feathers/src/client/fetch.test.ts
@@ -0,0 +1,135 @@
+import { beforeAll, describe, it, expect } from 'vitest'
+import { feathers } from '../index.js'
+import { clientTests } from '../../fixtures/client.js'
+import { NotAcceptable, NotFound, MethodNotAllowed } from '../errors.js'
+
+import { getApp, createTestServer, TestServiceTypes, verify } from '../../fixtures/index.js'
+import { fetchClient } from './index.js'
+
+describe('fetch REST connector', function () {
+ const port = 8888
+ const baseUrl = `http://localhost:${port}`
+ const connection = fetchClient(fetch, { baseUrl })
+ const app = feathers().configure(connection)
+ const service = app.service('todos')
+
+ beforeAll(async () => {
+ const testApp = getApp()
+ await createTestServer(port, testApp)
+ })
+
+ it('supports custom headers', async () => {
+ const headers = {
+ Authorization: 'let-me-in'
+ }
+ const todo = await service.get('taxes', {
+ headers,
+ query: { returnheaders: true }
+ })
+
+ expect(todo.headers?.authorization).toBe('let-me-in')
+ })
+
+ it('supports params.connection', async () => {
+ const connection = {
+ headers: {
+ Authorization: 'let-me-in'
+ }
+ }
+ const todo = await service.get('taxes', {
+ connection,
+ query: { returnheaders: true }
+ })
+
+ expect(todo.headers?.authorization).toBe('let-me-in')
+ })
+
+ it('handles errors properly', async () => {
+ await expect(() => service.get('notfound', {})).rejects.toMatchObject({
+ code: 404,
+ name: 'NotFound',
+ message: 'Not found'
+ })
+
+ await expect(() => service.get('notfound', {})).rejects.toBeInstanceOf(NotFound)
+ })
+
+ it('supports nested arrays in queries', async () => {
+ const query = { test: { $in: ['0', '1', '2'] }, returnquery: 'true' }
+ const data = await service.get('dishes', { query })
+
+ expect(data.query).toEqual(query)
+ })
+
+ it('can initialize a client instance', async () => {
+ const init = fetchClient(fetch, {
+ baseUrl: baseUrl
+ })
+ const todoService = init.service('todos')
+
+ expect(todoService).toBeInstanceOf(init.Service)
+
+ const todos = await todoService.find({})
+
+ verify.find(todos)
+ })
+
+ it('remove many', async () => {
+ const todo = await service.remove(null)
+
+ expect(todo).toEqual({ id: null })
+ })
+
+ it('converts feathers errors (#50)', async () => {
+ await expect(() => service.get('notacceptable', {})).rejects.toMatchObject({
+ code: 406,
+ name: 'NotAcceptable',
+ message: 'This is a Feathers error',
+ data: {
+ testData: true
+ }
+ })
+
+ await expect(() => service.get('notacceptable', {})).rejects.toBeInstanceOf(NotAcceptable)
+ })
+
+ it('returns null for 204 responses', async () => {
+ const response = await service.get('nocontent', {})
+ expect(response).toBeNull()
+ })
+
+ it('works with custom method .customMethod', async () => {
+ const result = await service.customMethod({ message: 'hi' }, {})
+
+ expect(result).toEqual({
+ data: { message: 'hi' },
+ provider: 'rest',
+ method: 'customMethod'
+ })
+ })
+
+ it('errors for non existing custom and existing internal method', async () => {
+ //@ts-expect-error Testing non existent method
+ await expect(() => service.wrongCustomMethod({})).rejects.toThrow(MethodNotAllowed)
+ //@ts-expect-error Testing method with parameters
+ await expect(() => service.internalMethod({})).rejects.toThrow(MethodNotAllowed)
+ })
+
+ it('supports async iterable streams', async () => {
+ const messages: any[] = []
+ const stream = await app.service('test').get('test')
+
+ for await (const data of stream) {
+ messages.push(data)
+ }
+
+ expect(messages).toHaveLength(5)
+ expect(messages[0]).toEqual({ message: 'Hello test 1' })
+ expect(messages[1]).toEqual({ message: 'Hello test 2' })
+ expect(messages[2]).toEqual({ message: 'Hello test 3' })
+ expect(messages[3]).toEqual({ message: 'Hello test 4' })
+ expect(messages[4]).toEqual({ message: 'Hello test 5' })
+ })
+
+ clientTests(app, 'todos')
+})
diff --git a/packages/feathers/src/client/fetch.ts b/packages/feathers/src/client/fetch.ts
new file mode 100644
index 0000000000..742ce90810
--- /dev/null
+++ b/packages/feathers/src/client/fetch.ts
@@ -0,0 +1,301 @@
+import { Params, Id, Query, NullableId } from '../declarations.js'
+import { Unavailable, convert, errors } from '../errors.js'
+import { _, stripSlashes } from '../commons.js'
+import { protectedProperties } from '../service.js'
+
+function toError(error: Error & { code: string }, status?: number) {
+ if (error.code === 'ECONNREFUSED') {
+ return new Unavailable(error.message, _.pick(error, 'address', 'port', 'config'))
+ }
+
+ return convert(error, status)
+}
+
+export interface FetchClientParams extends Params {
+ connection?: any
+}
+
+interface FetchClientSettings {
+ name: string
+ baseUrl: string
+ connection: typeof fetch
+ stringify: (query: Query) => string
+ events?: string[]
+}
+
+export type RequestOptions = Omit & { url: string; body?: unknown }
+
+export class FetchClient, P extends Params = FetchClientParams> {
+ name: string
+ base: string
+ connection: typeof fetch
+ stringify: (query: Query) => string
+ events?: string[]
+
+ constructor(settings: FetchClientSettings) {
+ this.name = stripSlashes(settings.name)
+ this.connection = settings.connection
+ this.base = `${settings.baseUrl}/${this.name}`
+ this.stringify = settings.stringify
+ this.events = settings.events
+ }
+
+ makeUrl(query: Query, id?: string | number | null, route?: { [key: string]: string }) {
+ let url = this.base
+
+ if (route) {
+ Object.keys(route).forEach((key) => {
+ url = url.replace(`:${key}`, route[key])
+ })
+ }
+
+ if (typeof id !== 'undefined' && id !== null) {
+ url += `/${encodeURIComponent(id)}`
+ }
+
+ return url + this.getQuery(query || {})
+ }
+
+ getQuery(query: Query) {
+ const queryString = this.stringify(query)
+
+ return queryString ? `?${queryString}` : ''
+ }
+
+ async request(options: RequestOptions, params: FetchClientParams = {}) {
+ const { url, ...requestInit } = options
+ const fetchOptions: RequestInit = {
+ ...requestInit,
+ ...params.connection
+ }
+
+ fetchOptions.headers = {
+ Accept: 'application/json',
+ ...fetchOptions.headers,
+ ...params.headers
+ }
+
+ if (options.body) {
+ fetchOptions.body = JSON.stringify(options.body)
+ fetchOptions.headers = {
+ 'Content-Type': 'application/json',
+ ...fetchOptions.headers
+ }
+ }
+
+ const response = await this.connection(url, fetchOptions)
+
+ await this.checkStatus(response)
+
+ if (response.status === 204) {
+ return null
+ }
+
+ if (response.headers.get('content-type') === 'text/event-stream') {
+ return this.handleEventStream(response)
+ }
+
+ return response.json()
+ }
+
+ callCustomMethod(method: string, body: unknown, params: FetchClientParams) {
+ return this.request(
+ {
+ url: this.makeUrl(params?.query, null, params?.route),
+ method: 'POST',
+ headers: {
+ 'X-Service-Method': method
+ },
+ body
+ },
+ params
+ )
+ }
+
+ async *handleEventStream(res: Response) {
+ const reader = res.body.getReader()
+ const decoder = new TextDecoder()
+
+ while (true) {
+ const { value, done } = await reader.read()
+
+ if (done) {
+ break
+ }
+
+ if (value) {
+ const text = decoder.decode(value)
+ const eventChunks = text.split('\n\n').filter(Boolean)
+
+ for (const chunk of eventChunks) {
+ const lines = chunk.split('\n')
+ const dataLine = lines.find((line) => line.startsWith('data: '))
+
+ if (dataLine) {
+ yield JSON.parse(dataLine.substring('data: '.length))
+ }
+ }
+ }
+ }
+ }
+
+ async checkStatus(response: Response) {
+ if (response.ok) {
+ return response
+ }
+
+ const ErrorClass = (errors as any)[response.status] || Error
+
+ let error: Error & { response: Response } = new ErrorClass('JSON parsing error')
+
+ try {
+ const data = await response.json()
+
+ error = await toError(data, response.status)
+ } catch (_error) {}
+
+ error.response = response
+
+ throw error
+ }
+
+ _find(params?: P) {
+ return this.request(
+ {
+ url: this.makeUrl(params.query, null, params.route),
+ method: 'GET',
+ headers: Object.assign({}, params.headers)
+ },
+ params
+ )
+ }
+
+ find(params?: P) {
+ return this._find(params)
+ }
+
+ async _get(id: Id, params?: P) {
+ if (typeof id === 'undefined') {
+ throw new Error("id for 'get' can not be undefined")
+ }
+
+ return this.request(
+ {
+ url: this.makeUrl(params.query, id, params.route),
+ method: 'GET'
+ },
+ params
+ )
+ }
+
+ get(id: Id, params?: P) {
+ return this._get(id, params)
+ }
+
+ _create(data: D, params?: P) {
+ return this.request(
+ {
+ url: this.makeUrl(params.query, null, params.route),
+ body: data,
+ method: 'POST'
+ },
+ params
+ )
+ }
+
+ create(data: D, params?: P) {
+ return this._create(data, params)
+ }
+
+ async _update(id: NullableId, data: D, params?: P) {
+ if (typeof id === 'undefined') {
+ throw new Error("id for 'update' can not be undefined, only 'null' when updating multiple entries")
+ }
+
+ return this.request(
+ {
+ url: this.makeUrl(params.query, id, params.route),
+ body: data,
+ method: 'PUT'
+ },
+ params
+ )
+ }
+
+ update(id: NullableId, data: D, params?: P) {
+ return this._update(id, data, params)
+ }
+
+ async _patch(id: NullableId, data: D, params?: P) {
+ if (typeof id === 'undefined') {
+ throw new Error("id for 'patch' can not be undefined, only 'null' when updating multiple entries")
+ }
+
+ return this.request(
+ {
+ url: this.makeUrl(params.query, id, params.route),
+ body: data,
+ method: 'PATCH'
+ },
+ params
+ )
+ }
+
+ patch(id: NullableId, data: D, params?: P) {
+ return this._patch(id, data, params)
+ }
+
+ async _remove(id: NullableId, params?: P) {
+ if (typeof id === 'undefined') {
+ throw new Error("id for 'remove' can not be undefined, only 'null' when removing multiple entries")
+ }
+
+ return this.request(
+ {
+ url: this.makeUrl(params.query, id, params.route),
+ method: 'DELETE'
+ },
+ params
+ )
+ }
+
+ remove(id: NullableId, params?: P) {
+ return this._remove(id, params)
+ }
+}
+
+export class ProxiedFetchClient<
+ T = any,
+ D = Partial,
+ P extends Params = FetchClientParams
+> extends FetchClient {
+ constructor(settings: FetchClientSettings) {
+ super(settings)
+
+ // Create and return a proxy after construction is complete
+ const proxy = new Proxy(this, {
+ get(target, prop, receiver) {
+ const value = Reflect.get(target, prop, receiver)
+ if (value !== undefined) {
+ return value
+ }
+
+ // Proxy other custom methods
+ if (
+ typeof prop === 'string' &&
+ !prop.startsWith('_') &&
+ !prop.startsWith('Symbol(') &&
+ !protectedProperties.includes(prop)
+ ) {
+ return function (data: any, params?: P) {
+ return target.callCustomMethod(prop, data, params)
+ }
+ }
+
+ return undefined
+ }
+ })
+
+ return proxy
+ }
+}
diff --git a/packages/feathers/src/client/index.ts b/packages/feathers/src/client/index.ts
new file mode 100644
index 0000000000..9f0420cd64
--- /dev/null
+++ b/packages/feathers/src/client/index.ts
@@ -0,0 +1,44 @@
+import qs from 'qs'
+import type { Application, Query } from '../declarations.js'
+import { FetchClient, ProxiedFetchClient } from './fetch.js'
+import { sseClient, SseClientOptions } from './sse.js'
+import { defaultServiceEvents } from '../service.js'
+
+export * from './fetch.js'
+export * from './types.js'
+export * from './sse.js'
+
+export type ClientOptions = {
+ baseUrl?: string
+ Service?: typeof FetchClient
+ stringify?: (query: Query) => string
+ sse?: string | SseClientOptions
+}
+
+export function fetchClient(connection: typeof fetch, options: ClientOptions = {}) {
+ const { stringify = qs.stringify, baseUrl = '', Service = ProxiedFetchClient } = options
+ const events = options.sse ? defaultServiceEvents : undefined
+ const sseOptions = typeof options.sse === 'string' ? { path: options.sse } : options.sse
+ const defaultService = function (name: string) {
+ return new Service({ baseUrl, name, connection, stringify, events })
+ }
+ const initialize = (_app: Application) => {
+ const app = _app as Application & { rest: typeof fetch }
+
+ if (app.rest !== undefined) {
+ throw new Error('Only one default client provider can be configured')
+ }
+
+ app.rest = connection
+ app.defaultService = defaultService
+
+ if (sseOptions) {
+ app.configure(sseClient(sseOptions))
+ }
+ }
+
+ initialize.Service = Service
+ initialize.service = defaultService
+
+ return initialize
+}
diff --git a/packages/feathers/src/client/sse.test.ts b/packages/feathers/src/client/sse.test.ts
new file mode 100644
index 0000000000..db1b3195e4
--- /dev/null
+++ b/packages/feathers/src/client/sse.test.ts
@@ -0,0 +1,188 @@
+import { beforeAll, afterAll, describe, it, expect } from 'vitest'
+import { Application, feathers, Params } from '../index.js'
+import { getApp, createTestServer, TestServiceTypes, Todo } from '../../fixtures/index.js'
+import { fetchClient, ReconnectingEvent } from './index.js'
+
+describe('SSE client', function () {
+ const port = 8890
+ const url = `http://localhost:${port}`
+
+ let server: any
+ let app: Application
+ let client1: Application
+ let client2: Application
+
+ beforeAll(async () => {
+ app = getApp()
+ app.on('connection', (connection: Params) => {
+ app.channel('general').join(connection)
+
+ const { channel } = connection.query
+
+ if (channel) {
+ app.channel(channel).join(connection)
+ }
+ })
+ app.publish((data: any) => {
+ if (typeof data.channel !== 'string') {
+ return app.channel('general')
+ } else {
+ return app.channel(data.channel)
+ }
+ })
+
+ server = await createTestServer(port, app)
+
+ client1 = feathers().configure(
+ fetchClient(fetch, {
+ baseUrl: url,
+ sse: 'sse'
+ })
+ )
+ client2 = feathers().configure(
+ fetchClient(fetch, {
+ baseUrl: url,
+ sse: 'sse'
+ })
+ )
+ })
+
+ afterAll(async () => {
+ server.close()
+ })
+
+ it('should stream basic SSE between clients, can abort sse', async () => {
+ const events: Todo[] = []
+
+ client1.service('sse').emit('start')
+
+ const controller = await new Promise((resolve) => {
+ client1.service('sse').once('connected', (data: AbortController) => resolve(data))
+ })
+
+ client1.service('todos').on('created', (data: Todo) => {
+ events.push(data)
+ })
+
+ await client2.service('todos').create({ text: 'todo 1', complete: true })
+ await Promise.all([
+ client2.service('todos').create({ text: 'todo 2', complete: false }),
+ client2.service('todos').create({ text: 'todo 3', complete: true }),
+ app.service('todos').create({ text: 'server todo', complete: false })
+ ])
+
+ await new Promise((resolve) => setTimeout(() => resolve(), 50))
+
+ controller.abort()
+
+ await client2.service('todos').create({ text: 'todo x', complete: true })
+ await new Promise((resolve) => setTimeout(() => resolve(), 50))
+
+ expect(events.length).toBe(4)
+ })
+
+ it('emits AbortController on successful connection', async () => {
+ const params = {
+ query: { message: 'testing' }
+ }
+
+ client1.service('sse').emit('start', params)
+
+ const controller = await new Promise((resolve) => {
+ client1.service('sse').once('connected', (data: AbortController) => resolve(data))
+ })
+
+ controller.abort()
+ expect(controller.signal.aborted).toBe(true)
+ })
+
+ it('only receive events for their channels', async () => {
+ const events: Todo[] = []
+
+ client1.service('sse').emit('start', { query: { channel: 'client' } })
+ client2.service('sse').emit('start', { query: { channel: 'client' } })
+
+ await Promise.all([
+ new Promise((resolve) => client1.service('sse').once('connected', resolve)),
+ new Promise((resolve) => client2.service('sse').once('connected', resolve))
+ ])
+
+ client1.service('todos').on('created', (todo: Todo) => events.push(todo))
+ client2.service('todos').on('created', (todo: Todo) => events.push(todo))
+
+ await client2.service('todos').create({
+ text: 'todo x',
+ complete: true,
+ channel: 'client'
+ })
+
+ await new Promise((resolve) => setTimeout(() => resolve(), 50))
+
+ expect(events.length).toBe(2)
+
+ await client2.service('todos').create({
+ text: 'todo x',
+ complete: true,
+ channel: 'notclient'
+ })
+
+ await new Promise((resolve) => setTimeout(() => resolve(), 50))
+
+ expect(events.length).toBe(2)
+ })
+
+ it('initiates reconnection when server is unavailable', async () => {
+ const reconnectPort = 8946
+ let server = await createTestServer(reconnectPort, app)
+ const reconnectClient = feathers().configure(
+ fetchClient(fetch, {
+ baseUrl: `http://localhost:${reconnectPort}`,
+ sse: {
+ path: 'sse',
+ reconnectionDelay: 50,
+ reconnectionDelayMax: 500
+ }
+ })
+ )
+ reconnectClient.service('sse').emit('start')
+
+ await new Promise((resolve) => {
+ reconnectClient.service('sse').once('connected', (data: AbortController) => resolve(data))
+ })
+
+ const disconnectEvent = new Promise((resolve) => {
+ reconnectClient.service('sse').once('disconnected', (error: Error) => resolve(error))
+ })
+ const reconnectingEvents = new Promise((resolve) => {
+ const retries: ReconnectingEvent[] = []
+
+ reconnectClient.service('sse').on('reconnecting', (info: ReconnectingEvent) => {
+ retries.push(info)
+ if (retries.length === 2) {
+ resolve(retries)
+ }
+ })
+ })
+
+ server.closeAllConnections()
+ server.close()
+
+ const reconnections = await reconnectingEvents
+
+ expect(reconnections).toHaveLength(2)
+ expect(reconnections[0]).toHaveProperty('delay')
+ expect(reconnections[0].attempt).toEqual(1)
+ expect(reconnections[1].attempt).toEqual(2)
+
+ expect(await disconnectEvent).toBeInstanceOf(Error)
+
+ server = await createTestServer(reconnectPort, app)
+
+ await new Promise((resolve) => {
+ reconnectClient.service('sse').once('connected', (data: AbortController) => resolve(data))
+ })
+
+ server.closeAllConnections()
+ server.close()
+ })
+})
diff --git a/packages/feathers/src/client/sse.ts b/packages/feathers/src/client/sse.ts
new file mode 100644
index 0000000000..d166cd134b
--- /dev/null
+++ b/packages/feathers/src/client/sse.ts
@@ -0,0 +1,101 @@
+import { Application, Params } from '../declarations.js'
+
+export interface SseClientOptions {
+ path: string
+ reconnectionDelay?: number
+ reconnectionDelayMax?: number
+}
+
+export interface ReconnectingEvent {
+ delay: number
+ attempt: number
+ timeout: number | null
+}
+
+function getDelay(attempt: number, reconnectionDelay: number, reconnectionDelayMax: number, jitter = 0.3) {
+ const baseDelay = Math.min(reconnectionDelay * Math.pow(2, attempt - 1), reconnectionDelayMax)
+ const jit = (Math.random() - 0.5) * (jitter * 2)
+
+ return Math.round(baseDelay * (1 + jit))
+}
+
+export function sseClient(options: SseClientOptions) {
+ return (client: Application) => {
+ const { path, reconnectionDelay = 1000, reconnectionDelayMax = 5000 } = options
+ const sseService = client.service(path)
+
+ let attempt = 0
+ let timeout: number | null = null
+
+ const reconnect = (params: Params) => {
+ if (timeout !== null) {
+ return
+ }
+
+ const delay = getDelay(++attempt, reconnectionDelay, reconnectionDelayMax)
+
+ timeout = setTimeout(() => {
+ timeout = null
+ connect(params)
+ }, delay) as unknown as number
+ sseService.emit('reconnecting', {
+ delay,
+ attempt,
+ timeout: timeout
+ })
+ }
+
+ const connect = (params: Params) => {
+ const abortController = new AbortController()
+ const sseParams = {
+ ...params,
+ connection: {
+ ...params.connection,
+ signal: abortController.signal
+ }
+ }
+
+ // Do not await the request since the promise won't resolve until an event happens
+ sseService
+ .find(sseParams)
+ .then(async (stream) => {
+ try {
+ attempt = 0
+
+ for await (const payload of stream) {
+ if (abortController.signal.aborted) {
+ break
+ }
+
+ try {
+ if (payload.path === options.path && payload.event === 'connected') {
+ sseService.emit('connected', abortController)
+ } else {
+ client.service(payload.path).emit(payload.event, payload.data)
+ }
+ } catch (error) {
+ sseService.emit('error', error)
+ }
+ }
+ } catch (error: unknown) {
+ if ((error as Error).name !== 'AbortError') {
+ throw error
+ }
+ }
+ })
+ .catch((error) => {
+ abortController.abort()
+ sseService.emit('disconnected', error)
+
+ if ((error as Error).name !== 'AbortError') {
+ timeout = null
+ reconnect(params)
+ }
+ })
+ }
+
+ sseService.on('start', (params: Params = {}) => {
+ connect(params)
+ })
+ }
+}
diff --git a/packages/feathers/src/client/types.ts b/packages/feathers/src/client/types.ts
new file mode 100644
index 0000000000..3e1602a4f0
--- /dev/null
+++ b/packages/feathers/src/client/types.ts
@@ -0,0 +1,39 @@
+// Utility type to pick only the `query` property from Params if it exists
+type QueryParams = T extends { query?: infer Q } ? { query?: Q } : never
+
+// Infer the types of `id`, `data`, and `params` for a given method signature
+type MethodParams = T extends (...args: any[]) => any
+ ? Parameters extends [infer I, infer D, infer P]
+ ? [I, D, Omit & QueryParams] | [I, D]
+ : Parameters extends [infer I, infer P]
+ ? [I, Omit & QueryParams] | [I]
+ : Parameters extends [infer P]
+ ? [Omit & QueryParams] | []
+ : never
+ : never
+
+// Infer the return type of a given method
+type MethodReturnType = T extends (...args: any[]) => infer R ? R : any
+
+// Define a type that represents the methods and their inferred types
+export type PublicServiceMethods = {
+ [K in keyof S]: S[K] extends (...args: any[]) => Promise
+ ? (...args: MethodParams) => MethodReturnType
+ : never
+}
+
+type ConditionalPick = {
+ [Key in keyof Base]: Key extends Condition ? Base[Key] : never
+}
+
+type NonNeverKeys = {
+ [Key in keyof T]: T[Key] extends never ? never : Key
+}[keyof T]
+
+type ConditionalPublicMethods = Pick>>
+
+type DefaultMethodNames = 'create' | 'find' | 'get' | 'update' | 'remove' | 'patch'
+
+export type ClientServices = {
+ [K in keyof ST]: ConditionalPublicMethods, DefaultMethodNames>
+}
diff --git a/packages/commons/test/utils.test.ts b/packages/feathers/src/commons.test.ts
similarity index 98%
rename from packages/commons/test/utils.test.ts
rename to packages/feathers/src/commons.test.ts
index 53d51978ab..424d82f08b 100644
--- a/packages/commons/test/utils.test.ts
+++ b/packages/feathers/src/commons.test.ts
@@ -1,8 +1,9 @@
/* tslint:disable:no-unused-expression */
+import { describe, it } from 'vitest'
import { strict as assert } from 'assert'
-import { _, stripSlashes, isPromise, createSymbol } from '../src'
+import { _, stripSlashes, isPromise, createSymbol } from '../src/commons.js'
-describe('@feathersjs/commons utils', () => {
+describe('feathers/commons utils', () => {
it('stripSlashes', () => {
assert.equal(stripSlashes('some/thing'), 'some/thing')
assert.equal(stripSlashes('/some/thing'), 'some/thing')
diff --git a/packages/commons/src/index.ts b/packages/feathers/src/commons.ts
similarity index 98%
rename from packages/commons/src/index.ts
rename to packages/feathers/src/commons.ts
index 9455252384..a6d06cbdaf 100644
--- a/packages/commons/src/index.ts
+++ b/packages/feathers/src/commons.ts
@@ -99,4 +99,4 @@ export function createSymbol(name: string) {
return typeof Symbol !== 'undefined' ? Symbol.for(name) : name
}
-export * from './debug'
+export * from './debug.js'
diff --git a/packages/commons/test/debug.test.ts b/packages/feathers/src/debug.test.ts
similarity index 87%
rename from packages/commons/test/debug.test.ts
rename to packages/feathers/src/debug.test.ts
index 2089af9b0c..8e0da19a52 100644
--- a/packages/commons/test/debug.test.ts
+++ b/packages/feathers/src/debug.test.ts
@@ -1,5 +1,6 @@
+import { describe, it } from 'vitest'
import { strict as assert } from 'assert'
-import { createDebug, setDebug, noopDebug } from '../src'
+import { createDebug, setDebug, noopDebug } from '../src/debug.js'
const myDebug = createDebug('hello test')
diff --git a/packages/commons/src/debug.ts b/packages/feathers/src/debug.ts
similarity index 91%
rename from packages/commons/src/debug.ts
rename to packages/feathers/src/debug.ts
index 5c15e62cf7..1922c03ee4 100644
--- a/packages/commons/src/debug.ts
+++ b/packages/feathers/src/debug.ts
@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
export type DebugFunction = (...args: any[]) => void
export type DebugInitializer = (name: string) => DebugFunction
diff --git a/packages/feathers/test/declarations.test.ts b/packages/feathers/src/declarations.test.ts
similarity index 94%
rename from packages/feathers/test/declarations.test.ts
rename to packages/feathers/src/declarations.test.ts
index 1ee2389dc7..e917249847 100644
--- a/packages/feathers/test/declarations.test.ts
+++ b/packages/feathers/src/declarations.test.ts
@@ -1,6 +1,7 @@
+import { describe, it } from 'vitest'
import assert from 'assert'
-import { hooks } from '@feathersjs/hooks'
-import { feathers, ServiceInterface, Application, HookContext, NextFunction } from '../src'
+import { hooks } from '../src/hooks/index.js'
+import { feathers, ServiceInterface, Application, HookContext, NextFunction } from '../src/index.js'
interface Todo {
id: number
diff --git a/packages/feathers/src/declarations.ts b/packages/feathers/src/declarations.ts
index aece46eebd..1d09404a45 100644
--- a/packages/feathers/src/declarations.ts
+++ b/packages/feathers/src/declarations.ts
@@ -1,5 +1,6 @@
import { EventEmitter } from 'events'
-import { NextFunction, HookContext as BaseHookContext } from '@feathersjs/hooks'
+import type { Router } from './router.js'
+import { NextFunction, HookContext as BaseHookContext } from './hooks/index.js'
type SelfOrArray = S | S[]
type OptionalPick = Pick>
@@ -138,6 +139,12 @@ export type ServiceInterface<
export interface ServiceAddons extends EventEmitter {
id?: string
hooks(options: HookOptions): this
+
+ publish(publisher: Publisher, A, this>): this
+ publish(event: Event, publisher: Publisher
+ 