@feathersjs/adapter-commons 5.0.0-pre.9 → 5.0.1

package/src/query.ts

@@ -0,0 +1,152 @@
+import { _ } from '@feathersjs/commons'
+import { BadRequest } from '@feathersjs/errors'
+import { Query } from '@feathersjs/feathers'
+import { FilterQueryOptions, FilterSettings, PaginationParams } from './declarations'
+
+const parse = (value: any) => (typeof value !== 'undefined' ? parseInt(value, 10) : value)
+
+const isPlainObject = (value: any) => _.isObject(value) && value.constructor === {}.constructor
+
+const validateQueryProperty = (query: any, operators: string[] = []): Query => {
+  if (!isPlainObject(query)) {
+    return query
+  }
+
+  for (const key of Object.keys(query)) {
+    if (key.startsWith('$') && !operators.includes(key)) {
+      throw new BadRequest(`Invalid query parameter ${key}`, query)
+    }
+
+    const value = query[key]
+
+    if (isPlainObject(value)) {
+      query[key] = validateQueryProperty(value, operators)
+    }
+  }
+
+  return {
+    ...query
+  }
+}
+
+const getFilters = (query: Query, settings: FilterQueryOptions) => {
+  const filterNames = Object.keys(settings.filters)
+
+  return filterNames.reduce((current, key) => {
+    const queryValue = query[key]
+    const filter = settings.filters[key]
+
+    if (filter) {
+      const value = typeof filter === 'function' ? filter(queryValue, settings) : queryValue
+
+      if (value !== undefined) {
+        current[key] = value
+      }
+    }
+
+    return current
+  }, {} as { [key: string]: any })
+}
+
+const getQuery = (query: Query, settings: FilterQueryOptions) => {
+  const keys = Object.keys(query).concat(Object.getOwnPropertySymbols(query) as any as string[])
+
+  return keys.reduce((result, key) => {
+    if (typeof key === 'string' && key.startsWith('$')) {
+      if (settings.filters[key] === undefined) {
+        throw new BadRequest(`Invalid filter value ${key}`)
+      }
+    } else {
+      result[key] = validateQueryProperty(query[key], settings.operators)
+    }
+
+    return result
+  }, {} as Query)
+}
+
+/**
+ * Returns the converted `$limit` value based on the `paginate` configuration.
+ * @param _limit The limit value
+ * @param paginate The pagination options
+ * @returns The converted $limit value
+ */
+export const getLimit = (_limit: any, paginate?: PaginationParams) => {
+  const limit = parse(_limit)
+
+  if (paginate && (paginate.default || paginate.max)) {
+    const base = paginate.default || 0
+    const lower = typeof limit === 'number' && !isNaN(limit) && limit >= 0 ? limit : base
+    const upper = typeof paginate.max === 'number' ? paginate.max : Number.MAX_VALUE
+
+    return Math.min(lower, upper)
+  }
+
+  return limit
+}
+
+export const OPERATORS = ['$in', '$nin', '$lt', '$lte', '$gt', '$gte', '$ne', '$or']
+
+export const FILTERS: FilterSettings = {
+  $skip: (value: any) => parse(value),
+  $sort: (sort: any): { [key: string]: number } => {
+    if (typeof sort !== 'object' || Array.isArray(sort)) {
+      return sort
+    }
+
+    return Object.keys(sort).reduce((result, key) => {
+      result[key] = typeof sort[key] === 'object' ? sort[key] : parse(sort[key])
+
+      return result
+    }, {} as { [key: string]: number })
+  },
+  $limit: (_limit: any, { paginate }: FilterQueryOptions) => getLimit(_limit, paginate),
+  $select: (select: any) => {
+    if (Array.isArray(select)) {
+      return select.map((current) => `${current}`)
+    }
+
+    return select
+  },
+  $or: (or: any, { operators }: FilterQueryOptions) => {
+    if (Array.isArray(or)) {
+      return or.map((current) => validateQueryProperty(current, operators))
+    }
+
+    return or
+  },
+  $and: (and: any, { operators }: FilterQueryOptions) => {
+    if (Array.isArray(and)) {
+      return and.map((current) => validateQueryProperty(current, operators))
+    }
+
+    return and
+  }
+}
+
+/**
+ * Converts Feathers special query parameters and pagination settings
+ * and returns them separately as `filters` and the rest of the query
+ * as `query`. `options` also gets passed the pagination settings and
+ * a list of additional `operators` to allow when querying properties.
+ *
+ * @param query The initial query
+ * @param options Options for filtering the query
+ * @returns An object with `query` which contains the query without `filters`
+ * and `filters` which contains the converted values for each filter.
+ */
+export function filterQuery(_query: Query, options: FilterQueryOptions = {}) {
+  const query = _query || {}
+  const settings = {
+    ...options,
+    filters: {
+      ...FILTERS,
+      ...options.filters
+    },
+    operators: OPERATORS.concat(options.operators || [])
+  }
+
+  return {
+    filters: getFilters(query, settings),
+    query: getQuery(query, settings)
+  }
+}

package/src/service.ts

@@ -1,231 +1,188 @@
-import { NotImplemented, BadRequest, MethodNotAllowed } from '@feathersjs/errors';
-import { ServiceMethods, Params, Id, NullableId, Paginated } from '@feathersjs/feathers';
-import { filterQuery } from './filter-query';
+import { Id, Paginated, Query } from '@feathersjs/feathers'
+import {
+  AdapterParams,
+  AdapterServiceOptions,
+  InternalServiceMethods,
+  PaginationOptions
+} from './declarations'
+import { filterQuery } from './query'
 
-const callMethod = (self: any, name: any, ...args: any[]) => {
-  if (typeof self[name] !== 'function') {
-    return Promise.reject(new NotImplemented(`Method ${name} not available`));
-  }
-
-  return self[name](...args);
-};
+export const VALIDATED = Symbol.for('@feathersjs/adapter/sanitized')
 
 const alwaysMulti: { [key: string]: boolean } = {
   find: true,
   get: false,
   update: false
-};
-
-export interface ServiceOptions {
-  events?: string[];
-  multi: boolean|string[];
-  id: string;
-  paginate: {
-    default?: number;
-    max?: number;
-  }
-  whitelist?: string[];
-  allow: string[];
-  filters: string[];
-}
-
-export interface AdapterOptions<M = any> extends Pick<ServiceOptions, 'multi'|'allow'|'paginate'> {
-  Model?: M;
-}
-
-export interface AdapterParams<M = any> extends Params {
-  adapter?: Partial<AdapterOptions<M>>;
 }
 
 /**
- * Hook-less (internal) service methods. Directly call database adapter service methods
- * without running any service-level hooks. This can be useful if you need the raw data
- * from the service and don't want to trigger any of its hooks.
- *
- * Important: These methods are only available internally on the server, not on the client
- * side and only for the Feathers database adapters.
- *
- * These methods do not trigger events.
- *
- * @see {@link https://docs.feathersjs.com/guides/migrating.html#hook-less-service-methods}
+ * An abstract base class that a database adapter can extend from to implement the
+ * `__find`, `__get`, `__update`, `__patch` and `__remove` methods.
  */
-export interface InternalServiceMethods<T = any, D = Partial<T>> {
+export abstract class AdapterBase<
+  Result = any,
+  Data = Result,
+  PatchData = Partial<Data>,
+  ServiceParams extends AdapterParams = AdapterParams,
+  Options extends AdapterServiceOptions = AdapterServiceOptions,
+  IdType = Id
+> implements InternalServiceMethods<Result, Data, PatchData, ServiceParams, IdType>
+{
+  options: Options
+
+  constructor(options: Options) {
+    this.options = {
+      id: 'id',
+      events: [],
+      paginate: false,
+      multi: false,
+      filters: {},
+      operators: [],
+      ...options
+    }
+  }
+
+  get id() {
+    return this.options.id
+  }
+
+  get events() {
+    return this.options.events
+  }
 
   /**
-   * Retrieve all resources from this service, skipping any service-level hooks.
+   * Check if this adapter allows multiple updates for a method.
+   * @param method The method name to check.
+   * @param params The service call params.
+   * @returns Wether or not multiple updates are allowed.
+   */
+  allowsMulti(method: string, params: ServiceParams = {} as ServiceParams) {
+    const always = alwaysMulti[method]
+
+    if (typeof always !== 'undefined') {
+      return always
+    }
+
+    const { multi } = this.getOptions(params)
+
+    if (multi === true || !multi) {
+      return multi
+    }
+
+    return multi.includes(method)
+  }
+
+  /**
+   * Returns the combined options for a service call. Options will be merged
+   * with `this.options` and `params.adapter` for dynamic overrides.
    *
-   * @param params - Service call parameters {@link Params}
-   * @see {@link HookLessServiceMethods}
-   * @see {@link https://docs.feathersjs.com/api/services.html#find-params|Feathers API Documentation: .find(params)}
+   * @param params The parameters for the service method call
+   * @returns The actual options for this call
+   */
+  getOptions(params: ServiceParams): Options {
+    const paginate = params.paginate !== undefined ? params.paginate : this.options.paginate
+
+    return {
+      ...this.options,
+      paginate,
+      ...params.adapter
+    }
+  }
+
+  /**
+   * Returns a sanitized version of `params.query`, converting filter values
+   * (like $limit and $skip) into the expected type. Will throw an error if
+   * a `$` prefixed filter or operator value that is not allowed in `filters`
+   * or `operators` is encountered.
+   *
+   * @param params The service call parameter.
+   * @returns A new object containing the sanitized query.
+   */
+  async sanitizeQuery(params: ServiceParams = {} as ServiceParams): Promise<Query> {
+    // We don't need legacy query sanitisation if the query has been validated by a schema already
+    if (params.query && (params.query as any)[VALIDATED]) {
+      return params.query || {}
+    }
+
+    const options = this.getOptions(params)
+    const { query, filters } = filterQuery(params.query, options)
+
+    return {
+      ...filters,
+      ...query
+    }
+  }
+
+  /**
+   * Retrieve all resources from this service.
+   * Does not sanitize the query and should only be used on the server.
+   *
+   * @param _params - Service call parameters {@link ServiceParams}
    */
-  _find (params?: AdapterParams): Promise<T | T[] | Paginated<T>>;
+  abstract _find(_params?: ServiceParams & { paginate?: PaginationOptions }): Promise<Paginated<Result>>
+  abstract _find(_params?: ServiceParams & { paginate: false }): Promise<Result[]>
+  abstract _find(params?: ServiceParams): Promise<Result[] | Paginated<Result>>
 
   /**
    * Retrieve a single resource matching the given ID, skipping any service-level hooks.
+   * Does not sanitize the query and should only be used on the server.
    *
    * @param id - ID of the resource to locate
-   * @param params - Service call parameters {@link Params}
+   * @param params - Service call parameters {@link ServiceParams}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#get-id-params|Feathers API Documentation: .get(id, params)}
    */
-  _get (id: Id, params?: AdapterParams): Promise<T>;
+  abstract _get(id: IdType, params?: ServiceParams): Promise<Result>
 
   /**
    * Create a new resource for this service, skipping any service-level hooks.
+   * Does not check if multiple updates are allowed and should only be used on the server.
    *
    * @param data - Data to insert into this service.
-   * @param params - Service call parameters {@link Params}
+   * @param params - Service call parameters {@link ServiceParams}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#create-data-params|Feathers API Documentation: .create(data, params)}
    */
-  _create (data: D | D[], params?: AdapterParams): Promise<T | T[]>;
+  abstract _create(data: Data, params?: ServiceParams): Promise<Result>
+  abstract _create(data: Data[], params?: ServiceParams): Promise<Result[]>
+  abstract _create(data: Data | Data[], params?: ServiceParams): Promise<Result | Result[]>
 
   /**
-   * Replace any resources matching the given ID with the given data, skipping any service-level hooks.
+   * Completely replace the resource identified by id, skipping any service-level hooks.
+   * Does not sanitize the query and should only be used on the server.
    *
    * @param id - ID of the resource to be updated
    * @param data - Data to be put in place of the current resource.
-   * @param params - Service call parameters {@link Params}
+   * @param params - Service call parameters {@link ServiceParams}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#update-id-data-params|Feathers API Documentation: .update(id, data, params)}
    */
-  _update (id: Id, data: D, params?: AdapterParams): Promise<T>;
+  abstract _update(id: IdType, data: Data, params?: ServiceParams): Promise<Result>
 
   /**
    * Merge any resources matching the given ID with the given data, skipping any service-level hooks.
+   * Does not sanitize the query and should only be used on the server.
    *
    * @param id - ID of the resource to be patched
    * @param data - Data to merge with the current resource.
-   * @param params - Service call parameters {@link Params}
+   * @param params - Service call parameters {@link ServiceParams}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#patch-id-data-params|Feathers API Documentation: .patch(id, data, params)}
    */
-  _patch (id: NullableId, data: D, params?: AdapterParams): Promise<T | T[]>;
+  abstract _patch(id: null, data: PatchData, params?: ServiceParams): Promise<Result[]>
+  abstract _patch(id: IdType, data: PatchData, params?: ServiceParams): Promise<Result>
+  abstract _patch(id: IdType | null, data: PatchData, params?: ServiceParams): Promise<Result | Result[]>
 
   /**
    * Remove resources matching the given ID from the this service, skipping any service-level hooks.
+   * Does not sanitize query and should only be used on the server.
    *
    * @param id - ID of the resource to be removed
-   * @param params - Service call parameters {@link Params}
+   * @param params - Service call parameters {@link ServiceParams}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#remove-id-params|Feathers API Documentation: .remove(id, params)}
    */
-  _remove (id: NullableId, params?: AdapterParams): Promise<T | T[]>;
-}
-
-export class AdapterService<
-  T = any,
-  D = Partial<T>,
-  O extends Partial<ServiceOptions> = Partial<ServiceOptions>
-> implements ServiceMethods<T|Paginated<T>, D> {
-  options: ServiceOptions & O;
-
-  constructor (options: O) {
-    this.options = Object.assign({
-      id: 'id',
-      events: [],
-      paginate: {},
-      multi: false,
-      filters: [],
-      allow: []
-    }, options);
-  }
-
-  get id () {
-    return this.options.id;
-  }
-
-  get events () {
-    return this.options.events;
-  }
-
-  filterQuery (params: AdapterParams = {}, opts: any = {}) {
-    const paginate = typeof params.paginate !== 'undefined'
-      ? params.paginate
-      : this.getOptions(params).paginate;
-    const { query = {} } = params;
-    const options = Object.assign({
-      operators: this.options.whitelist || this.options.allow || [],
-      filters: this.options.filters,
-      paginate
-    }, opts);
-    const result = filterQuery(query, options);
-
-    return Object.assign(result, { paginate });
-  }
-
-  allowsMulti (method: string, params: AdapterParams = {}) {
-    const always = alwaysMulti[method];
-
-    if (typeof always !== 'undefined') {
-      return always;
-    }
-
-    const { multi: option } = this.getOptions(params);
-
-    if (option === true || option === false) {
-      return option;
-    }
-
-    return option.includes(method);
-  }
-
-  getOptions (params: AdapterParams): ServiceOptions & { model?: any } {
-    return {
-      ...this.options,
-      ...params.adapter
-    }
-  }
-
-  find (params?: AdapterParams): Promise<T[] | Paginated<T>> {
-    return callMethod(this, '_find', params);
-  }
-
-  get (id: Id, params?: AdapterParams): Promise<T> {
-    return callMethod(this, '_get', id, params);
-  }
-
-  create (data: Partial<T>, params?: AdapterParams): Promise<T>;
-  create (data: Partial<T>[], params?: AdapterParams): Promise<T[]>;
-  create (data: Partial<T> | Partial<T>[], params?: AdapterParams): Promise<T | T[]> {
-    if (Array.isArray(data) && !this.allowsMulti('create', params)) {
-      return Promise.reject(new MethodNotAllowed('Can not create multiple entries'));
-    }
-
-    return callMethod(this, '_create', data, params);
-  }
-
-  update (id: Id, data: D, params?: AdapterParams): Promise<T> {
-    if (id === null || Array.isArray(data)) {
-      return Promise.reject(new BadRequest(
-        'You can not replace multiple instances. Did you mean \'patch\'?'
-      ));
-    }
-
-    return callMethod(this, '_update', id, data, params);
-  }
-
-  patch (id: Id, data: Partial<T>, params?: AdapterParams): Promise<T>;
-  patch (id: null, data: Partial<T>, params?: AdapterParams): Promise<T[]>;
-  patch (id: NullableId, data: Partial<T>, params?: AdapterParams): Promise<T | T[]>;
-  patch (id: NullableId, data: Partial<T>, params?: AdapterParams): Promise<T | T[]> {
-    if (id === null && !this.allowsMulti('patch', params)) {
-      return Promise.reject(new MethodNotAllowed('Can not patch multiple entries'));
-    }
-
-    return callMethod(this, '_patch', id, data, params);
-  }
-
-  remove (id: Id, params?: AdapterParams): Promise<T>;
-  remove (id: null, params?: AdapterParams): Promise<T[]>;
-  remove (id: NullableId, params?: AdapterParams): Promise<T | T[]>;
-  remove (id: NullableId, params?: AdapterParams): Promise<T | T[]> {
-    if (id === null && !this.allowsMulti('remove', params)) {
-      return Promise.reject(new MethodNotAllowed('Can not remove multiple entries'));
-    }
-
-    return callMethod(this, '_remove', id, params);
-  }
-
-  async setup () {}
+  abstract _remove(id: null, params?: ServiceParams): Promise<Result[]>
+  abstract _remove(id: IdType, params?: ServiceParams): Promise<Result>
+  abstract _remove(id: IdType | null, params?: ServiceParams): Promise<Result | Result[]>
 }