REST Client

npm install @feathersjs/rest-client --save

import { feathers } from '@feathersjs/feathers'
import rest from '@feathersjs/rest-client'

const app = feathers()

// Connect to the same as the browser URL (only in the browser)
const restClient = rest()

// Connect to a different URL
const restClient = rest('http://feathers-api.com')

// Configure an AJAX library (see below) with that client
app.configure(restClient.fetch(window.fetch.bind(window)))

// Connect to the `http://feathers-api.com/messages` service
const messages = app.service('messages')

app.service('messages').create(
  {
    text: 'A message from a REST client'
  },
  {
    headers: { 'X-Requested-With': 'FeathersJS' }
  }
)

app.configure(restClient.axios(axios))

app.service('messages').get(1, {
  connection: {
    // Axios specific options here
  }
})

// In Node
app.configure(restClient.fetch(fetch))

// In modern browsers
app.configure(restClient.fetch(window.fetch.bind(window)))

const controller = new AbortController()

app.configure(restClient.fetch(fetch))

app.service('messages').get(1, {
  connection: {
    signal: controller.signal
  }
})

controller.abort()

import superagent from 'superagent'

app.configure(restClient.superagent(superagent))

import axios from 'axios'

app.configure(restClient.axios(axios))

import axios from 'axios'

app.configure(
  restClient.axios(
    axios.create({
      headers: { 'X-Requested-With': 'My-Feathers-Frontend' }
    })
  )
)

// Create a FormData object
const formData = new FormData()
formData.append('file', fileInput.files[0])
formData.append('description', 'My uploaded file')

// Upload using the service - FormData is auto-detected
const result = await app.service('uploads').create(formData)

// Server receives:
{
  file: File,
  description: 'My uploaded file'
}

// Client
const formData = new FormData()
formData.append('files', file1)
formData.append('files', file2)
formData.append('files', file3)

// Server receives:
{
  files: [File, File, File] // All files in one array
}

// Stream a file to a service
const file = fileInput.files[0]
const stream = file.stream()

const result = await app.service('uploads').create(stream, {
  headers: {
    'Content-Type': file.type,
    'X-Filename': file.name
  }
})

class UploadService {
  async create(stream: ReadableStream, params: Params) {
    const filename = params.headers['x-filename']
    const contentType = params.headers['content-type']

    // Pipe directly to storage - no buffering
    await storage.upload(filename, stream, { contentType })

    return { filename, uploaded: true }
  }
}

async create(stream: ReadableStream, params: Params) {
  // Stream directly to R2/S3
  await env.MY_BUCKET.put(params.headers['x-filename'], stream)
  return { success: true }
}

// Client
const file = fileInput.files[0]

await app.service('csv-import').create(file.stream(), {
  headers: {
    'Content-Type': 'text/csv',
    'X-Import-Options': JSON.stringify({
      filename: file.name,
      tableName: 'products',
      skipHeader: true
    })
  }
})

// Server
async create(stream: ReadableStream, params: Params) {
  const options = JSON.parse(params.headers['x-import-options'])
  // options.filename, options.tableName, options.skipHeader
}

// Server - service returns an async generator
class ChatService {
  async *create(data: { prompt: string }) {
    const stream = await ai.generateStream(data.prompt)

    for await (const chunk of stream) {
      yield { type: 'text', content: chunk }
    }
  }
}

// Client - consume the stream
const response = app.service('chat').create({ prompt: 'Hello' })

for await (const chunk of response) {
  console.log(chunk.content) // Streams in real-time
}

// Example: Streaming AI chat with status updates
class AIChatService {
  async *create(data: { messages: Message[] }, params: Params) {
    yield { type: 'status', text: 'Thinking...' }

    const stream = await llm.chat(data.messages)

    for await (const token of stream) {
      yield { type: 'text', text: token }
    }

    yield { type: 'done' }
  }
}

// Client
let fullResponse = ''

for await (const event of app.service('ai-chat').create({ messages })) {
  if (event.type === 'status') {
    showStatus(event.text)
  } else if (event.type === 'text') {
    fullResponse += event.text
    updateUI(fullResponse)
  }
}

import { feathers } from '@feathersjs/feathers'
import type { Params } from '@feathersjs/feathers'
import rest from '@feathersjs/rest-client'
import type { RestService } from '@feathersjs/rest-client'

// `data` and return type of custom method
type CustomMethodData = { name: string }
type CustomMethodResponse = { acknowledged: boolean }

type ServiceTypes = {
  // The type is a RestService extended with custom methods
  myservice: RestService & {
    myCustomMethod(data: CustomMethodData, params: Params): Promise<CustomMethodResponse>
  }
}

const client = feathers<ServiceTypes>()

// Connect to the same as the browser URL (only in the browser)
const restClient = rest().fetch(window.fetch.bind(window))

// Connect to a different URL
const restClient = rest('http://feathers-api.com').fetch(window.fetch.bind(window))

// Configure an AJAX library (see below) with that client
client.configure(restClient)

// Register a REST client service with all methods listed
client.use('myservice', restClient.service('myservice'), {
  methods: ['find', 'get', 'create', 'update', 'patch', 'remove', 'myCustomMethod']
})

// Then it can be used like other service methods
client.service('myservice').myCustomMethod(data, params)

import { feathers } from '@feathersjs/feathers'
import rest from '@feathersjs/rest-client'

const app = feathers()

const client1 = rest('http://feathers-api.com').fetch(window.fetch.bind(window))
const client2 = rest('http://other-feathers-api.com').fetch(window.fetch.bind(window))

// With additional options to e.g. set authentication information
const client2 = rest('http://other-feathers-api.com').fetch(window.fetch.bind(window), {
  headers: {
    Authorization: 'Bearer <Token for other-feathers-api.com>'
  }
})

// Configuring this will initialize default services for http://feathers-api.com
app.configure(client1)

// Connect to the `http://feathers-api.com/messages` service
const messages = app.service('messages')

// Register /users service that points to http://other-feathers-api.com/users
app.use('users', client2.service('users'))

const users = app.service('users')

import type { Query } from '@feathersjs/feathers'
import { FetchClient } from '@feathersjs/rest-client'
import qs from 'qs'

class CustomFetch extends FetchClient {
  getQuery(query: Query) {
    if (Object.keys(query).length !== 0) {
      const queryString = qs.stringify(query, {
        strictNullHandling: true
      })

      return `?${queryString}`
    }

    return ''
  }
}

app.configure(restClient.fetch(fetch, CustomFetch))

// POST /authentication the Content-Type header set to application/json
{
  "strategy": "local",
  "email": "your email",
  "password": "your password"
}

curl -H "Content-Type: application/json" -X POST -d '{"strategy":"local","email":"your email","password":"your password"}' http://localhost:3030/authentication

curl -H "Content-Type: application/json" -H "Authorization: Bearer <your access token>" http://localhost:3030/messages

GET /messages?status=read&user=10

GET /messages?field[$operand]=value&field[$operand]=value2

GET /messages?status[$ne]=active

// Find all messages that are read, limit to 10, only include text field.
{"status": "read", "$limit":10, "$select": ["name"] } } // JSON

GET /messages?status=read&$limit=10&$select[]=text // HTTP

GET /messages/1

GET /messages/1?status=read

POST /messages
{ "text": "I really have to iron" }

POST /messages
[
  { "text": "I really have to iron" },
  { "text": "Do laundry" }
]

PUT /messages/2
{ "text": "I really have to do laundry" }

PUT /messages?status=unread
{ "status": "read" }

PATCH /messages/2
{ "status": "read" }

PATCH /messages?status=unread
{ "status": "read" }

DELETE /messages/2

DELETE /messages?status=archived

POST /messages

X-Service-Method: myCustomMethod

{
  "message": "Hello world"
}

curl -H "Content-Type: application/json" -H "X-Service-Method: myCustomMethod" -X POST -d '{"message": "Hello world"}' http://localhost:3030/myservice

import { feathers } from '@feathersjs/feathers'
import rest from '@feathersjs/rest-client'

const app = feathers()

// Connect to the same as the browser URL (only in the browser)
const restClient = rest()

// Connect to a different URL
const restClient = rest('http://feathers-api.com')

// Configure an AJAX library (see below) with that client
app.configure(restClient.fetch(window.fetch.bind(window)))

// Connect to the `http://feathers-api.com/messages` service
const messages = app.service('users/:userId/messages')

// Call the `http://feathers-api.com/users/2/messages` URL
messages.find({
  route: {
    userId: 2
  }
})

import rest from '@feathersjs/rest-client'
// usersMessagesPath contains 'users/:userId/messages'
import { createClient, usersMessagesPath } from 'my-app'

const connection = rest('https://myapp.com').fetch(window.fetch.bind(window))

const client = createClient(connection)

// Call the `https://myapp.com/users/2/messages` URL
client.service(usersMessagesPath).find({
  route: {
    userId: 2
  }
})