dove: strongly type app.configure

[fratzinger]

This idea is pretty similar to the use of @feathersjs/pinion and is not a breaking change.

This has a few quirks:

// Add this service to the service type index
declare module '../../declarations' {
  interface ServiceTypes {
    users: YourService
  }
}

It separates the service runtime registration (in src/services/index.ts) from the type (in src/services/your-service/your-service). If you just remove it from src/services/index.ts it will be typed.

What if we don't have to type Application explicitly in the declarations.ts file, but instead can use:

// src/app.ts
export const app = koa(feathers())
  // Load our app configuration (see config/ folder)
  .configure(configuration(configurationValidator))
  // Set up Koa middleware
  .configure(app => {
    app.use(cors())
    app.use(serveStatic(app.get('public')))
    app.use(errorHandler())
    app.use(parseAuthentication())
    app.use(bodyParser())
  })
  // Configure services and transports
  .configure(rest())
  .configure(app =>
    socketio({
      cors: {
        origin: app.get('origins')
      }
    })(app)
  )
  .configure(postgresql)
  .configure(authentication)
  .configure(services)
  .configure(channels)
  // Register hooks that run on all service methods
  .hooks({
    around: {
      all: [logErrorHook]
    },
    before: {},
    after: {},
    error: {}
  })
  // Register application setup and teardown hooks here
  .hooks({
    setup: [],
    teardown: []
  })

export type App = typeof app

Therefore configure needs to be strongly typed (like in pinion):

// configure signature
// something like:
function configure<A extends _Application, R extends A>(app: A, cb: (app: A) => void | R): R {
  return cb.call(app, app) as R
}

So now, if the configure callback returns a new type, it returns with the new type:

So if every src/services/your-service/your-service.ts file would return the typed app with the service and the src/services/index.ts file looked like the following, it should work:

export const services = <A extends Application, R extends A>(app: Application): R => {
  return app
    .configure(messages)
    .configure(users)
  // All services will be registered here
}

A strongly typed application from its runtime code.

[daffl]

It took me a few reads to get what you are suggesting 😆 I like it and I think we can totally change the signature to make it possible, I'm currently just a little hesitant to change it in the generated application since it would require a lot of documentation and example changes. Maybe for a v5.1 or v6?

[fratzinger]

Sorry, if it was not clear enough. Most of the time I use too few words to describe things. Thanks for catching up!

It's definitely something for v6. I also thought about file based routing. I eventually come up with a better written RFC.