nm3xyz · Oct 31, 2026
diff --git a/docs/api/databases/knex.md b/docs/api/databases/knex.md
@@ -73,6 +73,22 @@ The [common API options](./common.md#options) are:
 
 There are additionally several legacy options in the [common API options](./common.md#options)
 
+### RETURNING clause support
+
+`create` uses the `RETURNING` clause to retrieve the id of a newly created record for PostgreSQL, OracleDB, MSSQL and SQLite. For databases that support it but are not in this list, it can be enabled with the `returning` option of the [Knex configuration](https://knexjs.org/guide/#configuration-options). This is for example required for Firebird via [`knex-firebird-dialect`](https://www.npmjs.com/package/knex-firebird-dialect):
+
+```js
+const db = knex({
+  client: knexFirebirdDialect,
+  connection: {
+    /* ... */
+  },
+  returning: true
+})
+```
+
+Setting the option to a falsy value will fall back to the default list of clients.
+
 ### getModel([params])
 
 `service.getModel([params])` returns the [Knex](https://knexjs.org/guide/query-builder.html) client for this table.

diff --git a/packages/knex/src/adapter.ts b/packages/knex/src/adapter.ts
@@ -26,6 +26,24 @@ const OPERATORS = {
 
 const RETURNING_CLIENTS = ['postgresql', 'pg', 'oracledb', 'mssql', 'sqlite3']
 
+type ReturningConfig = {
+  returning?: boolean
+}
+
+/**
+ * Returns whether the database client supports the `RETURNING` clause on inserts.
+ *
+ * The `returning` option in the knex configuration can be used to enable it for
+ * clients that support it but are not in the default list (e.g. Firebird via
+ * `knex-firebird-dialect`). If it is not set or falsy, the default list of
+ * clients is used.
+ */
+export const supportsReturning = (client: Knex.Client) => {
+  const { returning } = (client.config || {}) as ReturningConfig
+
+  return Boolean(returning) || RETURNING_CLIENTS.includes(client.driverName)
+}
+
 export class KnexAdapter<
   Result,
   Data = Partial<Result>,
@@ -253,7 +271,7 @@ export class KnexAdapter<
     }
 
     const { client } = this.db(params)
-    const returning = RETURNING_CLIENTS.includes(client.driverName) ? [this.id] : []
+    const returning = supportsReturning(client) ? [this.id] : []
     const rows: any = await this.db(params)
       .insert(data, returning, { includeTriggerModifications: true })
       .catch(errorHandler)

diff --git a/packages/knex/test/index.test.ts b/packages/knex/test/index.test.ts
@@ -6,7 +6,14 @@ import { errors } from '@feathersjs/errors'
 import { Ajv, getValidator, querySyntax, hooks } from '@feathersjs/schema'
 
 import connection from './connection'
-import { ERROR, KnexAdapterParams, KnexService, transaction } from '../src/index'
+import {
+  ERROR,
+  KnexAdapter,
+  KnexAdapterParams,
+  KnexService,
+  supportsReturning,
+  transaction
+} from '../src/index'
 import { AdapterQuery } from '@feathersjs/adapter-commons/lib'
 
 const testSuite = adapterTests([
@@ -236,6 +243,62 @@ const peopleExtendedOps = new KnexService({
   }
 })
 
+describe('returning clause support', () => {
+  const client = (driverName: string, config: any = {}) => ({ driverName, config }) as unknown as Knex.Client
+
+  const createStubAdapter = (config: any) => {
+    const calls: string[][] = []
+    // Minimal stand-in for a knex instance: callable (like `knex('table')`) with
+    // the client information and an `insert` that records the returning argument
+    const Model: any = () => Model
+
+    Model.client = { driverName: 'node-firebird-driver-native', config }
+    Model.insert = (_data: any, returning: string[]) => {
+      calls.push(returning)
+
+      return Promise.resolve(returning.length > 0 ? [{ id: 42 }] : [1])
+    }
+
+    const service = new KnexAdapter<any>({ Model, name: 'people', id: 'id' })
+
+    service._get = async (id: any) => ({ id, name: 'Dave' })
+
+    return { service, calls }
+  }
+
+  it('uses the default list of clients when the returning option is not set', () => {
+    assert.strictEqual(supportsReturning(client('postgresql')), true)
+    assert.strictEqual(supportsReturning(client('oracledb')), true)
+    assert.strictEqual(supportsReturning(client('sqlite3')), true)
+    assert.strictEqual(supportsReturning(client('node-firebird-driver-native')), false)
+  })
+
+  it('can be enabled for a client that is not in the default list', () => {
+    assert.strictEqual(supportsReturning(client('node-firebird-driver-native', { returning: true })), true)
+  })
+
+  it('falls back to the default list when the returning option is falsy', () => {
+    assert.strictEqual(supportsReturning(client('node-firebird-driver-native', { returning: false })), false)
+    assert.strictEqual(supportsReturning(client('postgresql', { returning: false })), true)
+  })
+
+  it('passes the id to insert when the returning option is enabled', async () => {
+    const { service, calls } = createStubAdapter({ returning: true })
+    const created = await service._create({ name: 'Dave' })
+
+    assert.deepStrictEqual(calls, [['id']])
+    assert.strictEqual(created.id, 42)
+  })
+
+  it('does not pass the id to insert when it is not supported or enabled', async () => {
+    const { service, calls } = createStubAdapter({})
+    const created = await service._create({ name: 'Dave' })
+
+    assert.deepStrictEqual(calls, [[]])
+    assert.strictEqual(created.id, 1)
+  })
+})
+
 describe('Feathers Knex Service', () => {
   const app = feathers<ServiceTypes>()
     .hooks({