@feathersjs/feathers 5.0.0-pre.2 → 5.0.0-pre.20

package/src/declarations.ts

@@ -1,115 +1,125 @@
-import { EventEmitter } from 'events';
 import {
-  NextFunction, HookContext as BaseHookContext
-} from '@feathersjs/hooks';
+  EventEmitter, NextFunction, HookContext as BaseHookContext
+} from './dependencies';
 
 type SelfOrArray<S> = S | S[];
 type OptionalPick<T, K extends PropertyKey> = Pick<T, Extract<keyof T, K>>
 
-export { NextFunction };
+export type { NextFunction };
+
+export interface Paginated<T> {
+  total: number;
+  limit: number;
+  skip: number;
+  data: T[];
+}
 
 export interface ServiceOptions {
   events?: string[];
   methods?: string[];
   serviceEvents?: string[];
+  routeParams?: { [key: string]: any };
 }
 
-export interface ServiceMethods<T, D = Partial<T>> {
-  find (params?: Params): Promise<T | T[]>;
+export interface ServiceMethods<T = any, D = Partial<T>, P = Params> {
+  find (params?: P): Promise<T | T[]>;
 
-  get (id: Id, params?: Params): Promise<T>;
+  get (id: Id, params?: P): Promise<T>;
 
-  create (data: D, params?: Params): Promise<T>;
+  create (data: D, params?: P): Promise<T>;
 
-  update (id: NullableId, data: D, params?: Params): Promise<T | T[]>;
+  update (id: NullableId, data: D, params?: P): Promise<T | T[]>;
 
-  patch (id: NullableId, data: D, params?: Params): Promise<T | T[]>;
+  patch (id: NullableId, data: D, params?: P): Promise<T | T[]>;
 
-  remove (id: NullableId, params?: Params): Promise<T | T[]>;
+  remove (id: NullableId, params?: P): Promise<T | T[]>;
 
-  setup (app: Application, path: string): Promise<void>;
+  setup? (app: Application, path: string): Promise<void>;
+
+  teardown? (app: Application, path: string): Promise<void>;
 }
 
-export interface ServiceOverloads<T, D> {
-  create? (data: D[], params?: Params): Promise<T[]>;
+export interface ServiceOverloads<T = any, D = Partial<T>, P = Params> {
+  create? (data: D[], params?: P): Promise<T[]>;
 
-  update? (id: Id, data: D, params?: Params): Promise<T>;
+  update? (id: Id, data: D, params?: P): Promise<T>;
 
-  update? (id: null, data: D, params?: Params): Promise<T[]>;
+  update? (id: null, data: D, params?: P): Promise<T[]>;
 
-  patch? (id: Id, data: D, params?: Params): Promise<T>;
+  patch? (id: Id, data: D, params?: P): Promise<T>;
 
-  patch? (id: null, data: D, params?: Params): Promise<T[]>;
+  patch? (id: null, data: D, params?: P): Promise<T[]>;
 
-  remove? (id: Id, params?: Params): Promise<T>;
+  remove? (id: Id, params?: P): Promise<T>;
 
-  remove? (id: null, params?: Params): Promise<T[]>;
+  remove? (id: null, params?: P): Promise<T[]>;
 }
 
-export type Service<T, D = Partial<T>> =
-  ServiceMethods<T, D> &
-  ServiceOverloads<T, D>;
+export type Service<T = any, D = Partial<T>, P = Params> =
+  ServiceMethods<T, D, P> &
+  ServiceOverloads<T, D, P>;
 
-export type ServiceInterface<T, D = Partial<T>> =
-  Partial<ServiceMethods<T, D>>;
+export type ServiceInterface<T = any, D = Partial<T>, P = Params> =
+  Partial<ServiceMethods<T, D, P>>;
 
-export interface ServiceAddons<A, S> extends EventEmitter {
+export interface ServiceAddons<A = Application, S = Service> extends EventEmitter {
   id?: string;
   hooks (options: HookOptions<A, S>): this;
 }
 
-export interface ServiceHookOverloads<S> {
+export interface ServiceHookOverloads<S, P = Params> {
   find (
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 
   get (
     id: Id,
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 
   create (
     data: ServiceGenericData<S> | ServiceGenericData<S>[],
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 
   update (
     id: NullableId,
     data: ServiceGenericData<S>,
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 
   patch (
     id: NullableId,
     data: ServiceGenericData<S>,
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 
   remove (
     id: NullableId,
-    params: Params,
+    params: P,
     context: HookContext
   ): Promise<HookContext>;
 }
 
-export type FeathersService<A = FeathersApplication, S = Service<any>> =
+export type FeathersService<A = FeathersApplication, S = Service> =
   S & ServiceAddons<A, S> & OptionalPick<ServiceHookOverloads<S>, keyof S>;
 
-export type CustomMethod<Methods extends string> = {
-  [k in Methods]: <X = any> (data: any, params?: Params) => Promise<X>;
+export type CustomMethods<T extends {[key: string]: [any, any]}> = {
+  [K in keyof T]: (data: T[K][0], params?: Params) => Promise<T[K][1]>;
 }
 
-export type ServiceMixin<A> = (service: FeathersService<A>, path: string, options?: ServiceOptions) => void;
+export type ServiceMixin<A> = (service: FeathersService<A>, path: string, options: ServiceOptions) => void;
 
 export type ServiceGenericType<S> = S extends ServiceInterface<infer T> ? T : any;
 export type ServiceGenericData<S> = S extends ServiceInterface<infer _T, infer D> ? D : any;
+export type ServiceGenericParams<S> = S extends ServiceInterface<infer _T, infer _D, infer P> ? P : any;
 
-export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
+export interface FeathersApplication<Services = any, Settings = any> {
   /**
    * The Feathers application version
    */
@@ -118,7 +128,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
   /**
    * A list of callbacks that run when a new service is registered
    */
-  mixins: ServiceMixin<Application<ServiceTypes, AppSettings>>[];
+  mixins: ServiceMixin<Application<Services, Settings>>[];
 
   /**
    * The index of all services keyed by their path.
@@ -126,13 +136,13 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * __Important:__ Services should always be retrieved via `app.service('name')`
    * not via `app.services`.
    */
-  services: ServiceTypes;
+  services: Services;
 
   /**
    * The application settings that can be used via
    * `app.get` and `app.set`
    */
-  settings: AppSettings;
+  settings: Settings;
 
   /**
    * A private-ish indicator if `app.setup()` has been called already
@@ -142,14 +152,14 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
   /**
    * Contains all registered application level hooks.
    */
-  appHooks: HookMap<Application<ServiceTypes, AppSettings>, any>;
+  appHooks: HookMap<Application<Services, Settings>, any>;
 
   /**
    * Retrieve an application setting by name
    *
    * @param name The setting name
    */
-  get<L extends keyof AppSettings & string> (name: L): AppSettings[L];
+  get<L extends keyof Settings & string> (name: L): Settings[L];
 
   /**
    * Set an application setting
@@ -157,7 +167,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * @param name The setting name
    * @param value The setting value
    */
-  set<L extends keyof AppSettings & string> (name: L, value: AppSettings[L]): this;
+  set<L extends keyof Settings & string> (name: L, value: Settings[L]): this;
 
   /**
    * Runs a callback configure function with the current application instance.
@@ -173,7 +183,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    *
    * @param location The path of the service
    */
-  defaultService (location: string): ServiceInterface<any>;
+  defaultService (location: string): ServiceInterface;
 
   /**
    * Register a new service or a sub-app. When passed another
@@ -185,9 +195,9 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * Feathers application to use a sub-app under the `path` prefix.
    * @param options The options for this service
    */
-  use<L extends keyof ServiceTypes & string> (
+  use<L extends keyof Services & string> (
     path: L,
-    service: keyof any extends keyof ServiceTypes ? ServiceInterface<any> | Application : ServiceTypes[L],
+    service: keyof any extends keyof Services ? ServiceInterface | Application : Services[L],
     options?: ServiceOptions
   ): this;
 
@@ -198,23 +208,35 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    *
    * @param path The name of the service.
    */
-  service<L extends keyof ServiceTypes & string> (
+  service<L extends keyof Services & string> (
     path: L
-  ): FeathersService<this, keyof any extends keyof ServiceTypes ? Service<any> : ServiceTypes[L]>;
+  ): FeathersService<this, keyof any extends keyof Services ? Service : Services[L]>;
 
+  /**
+   * Set up the application and call all services `.setup` method if available.
+   *
+   * @param server A server instance (optional)
+   */
   setup (server?: any): Promise<this>;
 
+  /**
+   * Tear down the application and call all services `.teardown` method if available.
+   *
+   * @param server A server instance (optional)
+   */
+  teardown (server?: any): Promise<this>;
+
   /**
    * Register application level hooks.
    *
    * @param map The application hook settings.
    */
-  hooks (map: HookOptions<this, any>): this;
+  hooks (map: ApplicationHookOptions<this>): this;
 }
 
 // This needs to be an interface instead of a type
 // so that the declaration can be extended by other modules
-export interface Application<ServiceTypes = any, AppSettings = any> extends FeathersApplication<ServiceTypes, AppSettings>, EventEmitter {
+export interface Application<Services = any, Settings = any> extends FeathersApplication<Services, Settings>, EventEmitter {
 
 }
 
@@ -225,12 +247,26 @@ export interface Query {
   [key: string]: any;
 }
 
-export interface Params {
-  query?: Query;
+export interface Params<Q = Query> {
+  query?: Q;
   provider?: string;
-  route?: { [key: string]: string };
+  route?: { [key: string]: any };
   headers?: { [key: string]: any };
-  [key: string]: any; // (JL) not sure if we want this
+}
+
+export interface Http {
+  /**
+   * A writeable, optional property with status code override.
+   */
+  status?: number;
+  /**
+   * A writeable, optional property with headers.
+   */
+  headers?: { [key: string]: string | string[] };
+  /**
+   * A writeable, optional property with `Location` header's value.
+   */
+  location?: string;
 }
 
 export interface HookContext<A = Application, S = any> extends BaseHookContext<ServiceGenericType<S>> {
@@ -283,7 +319,7 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
    * A writeable property that contains the service method parameters (including
    * params.query).
    */
-  params: Params;
+  params: ServiceGenericParams<S>;
   /**
    * A writeable property containing the result of the successful service method call.
    * It is only available in after hooks.
@@ -303,33 +339,41 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
   /**
    * A writeable, optional property that allows to override the standard HTTP status
    * code that should be returned.
+   *
+   * @deprecated Use `http.status` instead.
    */
   statusCode?: number;
+  /**
+   * A writeable, optional property with options specific to HTTP transports.
+   */
+  http?: Http;
   /**
    * The event emitted by this method. Can be set to `null` to skip event emitting.
    */
   event: string|null;
 }
 
-// Legacy hook typings
-export type LegacyHookFunction<A = Application, S = Service<any, any>> =
+// Regular hook typings
+export type RegularHookFunction<A = Application, S = Service> =
   (this: S, context: HookContext<A, S>) => (Promise<HookContext<Application, S> | void> | HookContext<Application, S> | void);
 
-type LegacyHookMethodMap<A, S> =
-  { [L in keyof S]?: SelfOrArray<LegacyHookFunction<A, S>>; } &
-  { all?: SelfOrArray<LegacyHookFunction<A, S>> };
+export type Hook<A = Application, S = Service> = RegularHookFunction<A, S>;
 
-type LegacyHookTypeMap<A, S> =
-  SelfOrArray<LegacyHookFunction<A, S>> | LegacyHookMethodMap<A, S>;
+type RegularHookMethodMap<A, S> =
+  { [L in keyof S]?: SelfOrArray<RegularHookFunction<A, S>>; } &
+  { all?: SelfOrArray<RegularHookFunction<A, S>> };
 
-export type LegacyHookMap<A, S> = {
-  before?: LegacyHookTypeMap<A, S>,
-  after?: LegacyHookTypeMap<A, S>,
-  error?: LegacyHookTypeMap<A, S>
+type RegularHookTypeMap<A, S> =
+  SelfOrArray<RegularHookFunction<A, S>> | RegularHookMethodMap<A, S>;
+
+export type RegularHookMap<A, S> = {
+  before?: RegularHookTypeMap<A, S>,
+  after?: RegularHookTypeMap<A, S>,
+  error?: RegularHookTypeMap<A, S>
 }
 
 // New @feathersjs/hook typings
-export type HookFunction<A = Application, S = Service<any, any>> =
+export type HookFunction<A = Application, S = Service> =
   (context: HookContext<A, S>, next: NextFunction) => Promise<void>;
 
 export type HookMap<A, S> = {
@@ -337,4 +381,19 @@ export type HookMap<A, S> = {
 };
 
 export type HookOptions<A, S> =
-  HookMap<A, S> | HookFunction<A, S>[] | LegacyHookMap<A, S>;
+  HookMap<A, S> | HookFunction<A, S>[] | RegularHookMap<A, S>;
+
+export interface ApplicationHookContext<A = Application> extends BaseHookContext {
+  app: A;
+  server: any;
+}
+
+export type ApplicationHookFunction<A> =
+  (context: ApplicationHookContext<A>, next: NextFunction) => Promise<void>;
+
+export type ApplicationHookMap<A> = {
+  setup?: ApplicationHookFunction<A>[],
+  teardown?: ApplicationHookFunction<A>[]
+}
+
+export type ApplicationHookOptions<A> = HookOptions<A, any> | ApplicationHookMap<A>

package/src/dependencies.ts

@@ -0,0 +1,5 @@
+import { EventEmitter } from 'events';
+export * from '@feathersjs/commons';
+export * from '@feathersjs/hooks';
+
+export { EventEmitter };

package/src/events.ts

@@ -1,6 +1,4 @@
-import { NextFunction } from '@feathersjs/hooks';
-import { EventEmitter } from 'events';
-
+import { NextFunction, EventEmitter } from './dependencies';
 import { HookContext, FeathersService } from './declarations';
 import { getServiceOptions, defaultEventMap } from './service';
 
@@ -15,7 +13,7 @@ export function eventHook (context: HookContext, next: NextFunction) {
     // This is used for custom events and for client services receiving event from the server
     if (typeof context.event === 'string' && !events.includes(context.event)) {
       const results = Array.isArray(context.result) ? context.result : [ context.result ];
-  
+
       results.forEach(element => (context as any).self.emit(context.event, element, context));
     }
   });
@@ -28,6 +26,6 @@ export function eventMixin<A> (service: FeathersService<A>) {
   if (!isEmitter) {
     Object.assign(service, EventEmitter.prototype);
   }
-  
+
   return service;
 }

package/src/hooks/index.ts

@@ -1,17 +1,25 @@
-import { getManager, HookContextData, HookManager, HookMap, HOOKS, hooks, Middleware } from '@feathersjs/hooks';
-import { Service, ServiceOptions, HookContext, FeathersService, Application } from '../declarations';
+import {
+  getManager, HookContextData, HookManager, HookMap, HOOKS, hooks, Middleware
+} from '../dependencies';
+import {
+  Service, ServiceOptions, HookContext, FeathersService, Application
+} from '../declarations';
 import { defaultServiceArguments, getHookMethods } from '../service';
 import {
-  collectLegacyHooks,
-  enableLegacyHooks,
-  fromAfterHook,
+  collectRegularHooks,
+  enableRegularHooks
+} from './regular';
+
+export {
   fromBeforeHook,
+  fromBeforeHooks,
+  fromAfterHook,
+  fromAfterHooks,
+  fromErrorHook,
   fromErrorHooks
-} from './legacy';
-
-export { fromAfterHook, fromBeforeHook, fromErrorHooks };
+} from './regular';
 
-export function createContext (service: Service<any>, method: string, data: HookContextData = {}) {
+export function createContext (service: Service, method: string, data: HookContextData = {}) {
   const createContext = (service as any)[method].createContext;
 
   if (typeof createContext !== 'function') {
@@ -30,11 +38,11 @@ export class FeathersHookManager<A> extends HookManager {
   collectMiddleware (self: any, args: any[]): Middleware[] {
     const app = this.app as any as Application;
     const appHooks = app.appHooks[HOOKS].concat(app.appHooks[this.method] || []);
-    const legacyAppHooks = collectLegacyHooks(this.app, this.method);
+    const regularAppHooks = collectRegularHooks(this.app, this.method);
     const middleware = super.collectMiddleware(self, args);
-    const legacyHooks = collectLegacyHooks(self, this.method);
+    const regularHooks = collectRegularHooks(self, this.method);
 
-    return [...appHooks, ...legacyAppHooks, ...middleware, ...legacyHooks];
+    return [...appHooks, ...regularAppHooks, ...middleware, ...regularHooks];
   }
 
   initializeContext (self: any, args: any[], context: HookContext) {
@@ -59,7 +67,9 @@ export function hookMixin<A> (
   }
 
   const app = this;
-  const serviceMethodHooks = getHookMethods(service, options).reduce((res, method) => {
+  const hookMethods = getHookMethods(service, options);
+
+  const serviceMethodHooks = hookMethods.reduce((res, method) => {
     const params = (defaultServiceArguments as any)[method] || [ 'data', 'params' ];
 
     res[method] = new FeathersHookManager<A>(app, method)
@@ -70,18 +80,25 @@ export function hookMixin<A> (
         method,
         service,
         event: null,
-        type: null
+        type: null,
+        get statusCode () {
+          return this.http?.status;
+        },
+        set statusCode (value: number) {
+          (this.http ||= {}).status = value;
+        }
       });
 
     return res;
   }, {} as HookMap);
-  const handleLegacyHooks = enableLegacyHooks(service);
+
+  const handleRegularHooks = enableRegularHooks(service, hookMethods);
 
   hooks(service, serviceMethodHooks);
 
   service.hooks = function (this: any, hookOptions: any) {
     if (hookOptions.before || hookOptions.after || hookOptions.error) {
-      return handleLegacyHooks.call(this, hookOptions);
+      return handleRegularHooks.call(this, hookOptions);
     }
 
     if (Array.isArray(hookOptions)) {