@feathersjs/adapter-commons 5.0.0-pre.3 → 5.0.0-pre.31

package/src/service.ts

@@ -1,82 +1,194 @@
-import { NotImplemented, BadRequest, MethodNotAllowed } from '@feathersjs/errors';
-import { ServiceMethods, Params, Id, NullableId } from '@feathersjs/feathers';
-import { filterQuery } from './filter-query';
-
-export interface Paginated<T> {
-  total: number;
-  limit: number;
-  skip: number;
-  data: T[];
-}
-
-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);
-};
+import { BadRequest, MethodNotAllowed } from '@feathersjs/errors'
+import { Id, NullableId, Paginated, Query } from '@feathersjs/feathers'
+import {
+  AdapterParams,
+  AdapterServiceOptions,
+  InternalServiceMethods,
+  PaginationOptions
+} from './declarations'
+import { filterQuery } from './query'
 
 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[];
-  filters: string[];
 }
 
 /**
- * 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> {
+export abstract class AdapterBase<
+  T = any,
+  D = Partial<T>,
+  P extends AdapterParams = AdapterParams,
+  O extends AdapterServiceOptions = AdapterServiceOptions
+> implements InternalServiceMethods<T, D, P>
+{
+  options: O
+
+  constructor(options: O) {
+    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: P = {} as P) {
+    const always = alwaysMulti[method]
+
+    if (typeof always !== 'undefined') {
+      return always
+    }
+
+    const { multi } = this.getOptions(params)
+
+    if (multi === true || multi === false) {
+      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 The parameters for the service method call
+   * @returns The actual options for this call
+   */
+  getOptions(params: P): O {
+    const paginate = params.paginate !== undefined ? params.paginate : this.options.paginate
+
+    return {
+      ...this.options,
+      paginate,
+      ...params.adapter
+    }
+  }
+
+  /**
+   * Sanitize the incoming data, e.g. removing invalid keywords etc.
+   *
+   * @param data The data to sanitize
+   * @param _params Service call parameters
+   * @returns The sanitized data
+   */
+  async sanitizeData<X = Partial<D>>(data: X, _params: P) {
+    return data
+  }
+
+  /**
+   * 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: P = {} as P): Promise<Query> {
+    const options = this.getOptions(params)
+    const { query, filters } = filterQuery(params.query, options)
+
+    return {
+      ...filters,
+      ...query
+    }
+  }
+
+  abstract $find(_params?: P & { paginate?: PaginationOptions }): Promise<Paginated<T>>
+  abstract $find(_params?: P & { paginate: false }): Promise<T[]>
+  abstract $find(params?: P): Promise<T[] | Paginated<T>>
+
+  /**
+   * Retrieve all resources from this service, skipping any service-level hooks but sanitize the query
+   * with allowed filters and properties by calling `sanitizeQuery`.
    *
    * @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)}
    */
-  _find (params?: Params): Promise<T | T[] | Paginated<T>>;
+  async _find(_params?: P & { paginate?: PaginationOptions }): Promise<Paginated<T>>
+  async _find(_params?: P & { paginate: false }): Promise<T[]>
+  async _find(params?: P): Promise<T | T[] | Paginated<T>>
+  async _find(params?: P): Promise<T | T[] | Paginated<T>> {
+    const query = await this.sanitizeQuery(params)
+
+    return this.$find({
+      ...params,
+      query
+    })
+  }
+
+  abstract $get(id: Id, params?: P): Promise<T>
 
   /**
-   * Retrieve a single resource matching the given ID, skipping any service-level hooks.
+   * Retrieve a single resource matching the given ID, skipping any service-level hooks but sanitize the query
+   * with allowed filters and properties by calling `sanitizeQuery`.
    *
    * @param id - ID of the resource to locate
    * @param params - Service call parameters {@link Params}
    * @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?: Params): Promise<T>;
+  async _get(id: Id, params?: P): Promise<T> {
+    const query = await this.sanitizeQuery(params)
+
+    return this.$get(id, {
+      ...params,
+      query
+    })
+  }
+
+  abstract $create(data: Partial<D>, params?: P): Promise<T>
+  abstract $create(data: Partial<D>[], params?: P): Promise<T[]>
+  abstract $create(data: Partial<D> | Partial<D>[], params?: P): Promise<T | T[]>
 
   /**
-   * Create a new resource for this service, skipping any service-level hooks.
+   * Create a new resource for this service, skipping any service-level hooks, sanitize the data
+   * and check if multiple updates are allowed.
    *
    * @param data - Data to insert into this service.
    * @param params - Service call parameters {@link Params}
    * @see {@link HookLessServiceMethods}
    * @see {@link https://docs.feathersjs.com/api/services.html#create-data-params|Feathers API Documentation: .create(data, params)}
    */
-  _create (data: Partial<T> | Partial<T>[], params?: Params): Promise<T | T[]>;
+  async _create(data: Partial<D>, params?: P): Promise<T>
+  async _create(data: Partial<D>[], params?: P): Promise<T[]>
+  async _create(data: Partial<D> | Partial<D>[], params?: P): Promise<T | T[]>
+  async _create(data: Partial<D> | Partial<D>[], params?: P): Promise<T | T[]> {
+    if (Array.isArray(data) && !this.allowsMulti('create', params)) {
+      throw new MethodNotAllowed('Can not create multiple entries')
+    }
+
+    const payload = Array.isArray(data)
+      ? await Promise.all(data.map((current) => this.sanitizeData(current, params)))
+      : await this.sanitizeData(data, params)
+
+    return this.$create(payload, params)
+  }
+
+  abstract $update(id: Id, data: D, params?: P): Promise<T>
 
   /**
    * Replace any resources matching the given ID with the given data, skipping any service-level hooks.
@@ -87,10 +199,27 @@ export interface InternalServiceMethods<T = any> {
    * @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: T, params?: Params): Promise<T>;
+  async _update(id: Id, data: D, params?: P): Promise<T> {
+    if (id === null || Array.isArray(data)) {
+      throw new BadRequest("You can not replace multiple instances. Did you mean 'patch'?")
+    }
+
+    const payload = await this.sanitizeData(data, params)
+    const query = await this.sanitizeQuery(params)
+
+    return this.$update(id, payload, {
+      ...params,
+      query
+    })
+  }
+
+  abstract $patch(id: null, data: Partial<D>, params?: P): Promise<T[]>
+  abstract $patch(id: Id, data: Partial<D>, params?: P): Promise<T>
+  abstract $patch(id: NullableId, data: Partial<D>, params?: P): Promise<T | T[]>
 
   /**
    * Merge any resources matching the given ID with the given data, skipping any service-level hooks.
+   * Sanitizes the query and data and checks it multiple updates are allowed.
    *
    * @param id - ID of the resource to be patched
    * @param data - Data to merge with the current resource.
@@ -98,120 +227,49 @@ export interface InternalServiceMethods<T = any> {
    * @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: Partial<T>, params?: Params): Promise<T | T[]>;
+  async _patch(id: null, data: Partial<D>, params?: P): Promise<T[]>
+  async _patch(id: Id, data: Partial<D>, params?: P): Promise<T>
+  async _patch(id: NullableId, data: Partial<D>, params?: P): Promise<T | T[]>
+  async _patch(id: NullableId, data: Partial<D>, params?: P): Promise<T | T[]> {
+    if (id === null && !this.allowsMulti('patch', params)) {
+      throw new MethodNotAllowed('Can not patch multiple entries')
+    }
+
+    const { $limit, ...query } = await this.sanitizeQuery(params)
+    const payload = await this.sanitizeData(data, params)
+
+    return this.$patch(id, payload, {
+      ...params,
+      query
+    })
+  }
+
+  abstract $remove(id: null, params?: P): Promise<T[]>
+  abstract $remove(id: Id, params?: P): Promise<T>
+  abstract $remove(id: NullableId, params?: P): Promise<T | T[]>
 
   /**
    * Remove resources matching the given ID from the this service, skipping any service-level hooks.
+   * Sanitized the query and verifies that multiple updates are allowed.
    *
    * @param id - ID of the resource to be removed
    * @param params - Service call parameters {@link Params}
    * @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?: Params): Promise<T | T[]>;
-}
-
-export class AdapterService<T = any> implements ServiceMethods<T|Paginated<T>> {
-  options: ServiceOptions;
-
-  constructor (options: Partial<ServiceOptions>) {
-    this.options = Object.assign({
-      id: 'id',
-      events: [],
-      paginate: {},
-      multi: false,
-      filters: [],
-      whitelist: []
-    }, options);
-  }
-
-  get id () {
-    return this.options.id;
-  }
-
-  get events () {
-    return this.options.events;
-  }
-
-  filterQuery (params: Params = {}, opts: any = {}) {
-    const paginate = typeof params.paginate !== 'undefined'
-      ? params.paginate : this.options.paginate;
-    const { query = {} } = params;
-    const options = Object.assign({
-      operators: this.options.whitelist || [],
-      filters: this.options.filters,
-      paginate
-    }, opts);
-    const result = filterQuery(query, options);
-
-    return Object.assign(result, { paginate });
-  }
-
-  allowsMulti (method: string) {
-    const always = alwaysMulti[method];
-
-    if (typeof always !== 'undefined') {
-      return always;
-    }
-
-    const option = this.options.multi;
-
-    if (option === true || option === false) {
-      return option;
-    } else {
-      return option.includes(method);
-    }
-  }
-
-  find (params?: Params): Promise<T[] | Paginated<T>> {
-    return callMethod(this, '_find', params);
-  }
-
-  get (id: Id, params?: Params): Promise<T> {
-    return callMethod(this, '_get', id, params);
-  }
-
-  create (data: Partial<T>, params?: Params): Promise<T>;
-  create (data: Partial<T>[], params?: Params): Promise<T[]>;
-  create (data: Partial<T> | Partial<T>[], params?: Params): Promise<T | T[]> {
-    if (Array.isArray(data) && !this.allowsMulti('create')) {
-      return Promise.reject(new MethodNotAllowed('Can not create multiple entries'));
+  async _remove(id: null, params?: P): Promise<T[]>
+  async _remove(id: Id, params?: P): Promise<T>
+  async _remove(id: NullableId, params?: P): Promise<T | T[]>
+  async _remove(id: NullableId, params?: P): Promise<T | T[]> {
+    if (id === null && !this.allowsMulti('remove', params)) {
+      throw new MethodNotAllowed('Can not remove multiple entries')
     }
 
-    return callMethod(this, '_create', data, params);
-  }
-
-  update (id: Id, data: T, params?: Params): Promise<T> {
-    if (id === null || Array.isArray(data)) {
-      return Promise.reject(new BadRequest(
-        'You can not replace multiple instances. Did you mean \'patch\'?'
-      ));
-    }
+    const { $limit, ...query } = await this.sanitizeQuery(params)
 
-    return callMethod(this, '_update', id, data, params);
+    return this.$remove(id, {
+      ...params,
+      query
+    })
   }
-
-  patch (id: Id, data: Partial<T>, params?: Params): Promise<T>;
-  patch (id: null, data: Partial<T>, params?: Params): Promise<T[]>;
-  patch (id: NullableId, data: Partial<T>, params?: Params): Promise<T | T[]>;
-  patch (id: NullableId, data: Partial<T>, params?: Params): Promise<T | T[]> {
-    if (id === null && !this.allowsMulti('patch')) {
-      return Promise.reject(new MethodNotAllowed('Can not patch multiple entries'));
-    }
-
-    return callMethod(this, '_patch', id, data, params);
-  }
-
-  remove (id: Id, params?: Params): Promise<T>;
-  remove (id: null, params?: Params): Promise<T[]>;
-  remove (id: NullableId, params?: Params): Promise<T | T[]>;
-  remove (id: NullableId, params?: Params): Promise<T | T[]> {
-    if (id === null && !this.allowsMulti('remove')) {
-      return Promise.reject(new MethodNotAllowed('Can not remove multiple entries'));
-    }
-
-    return callMethod(this, '_remove', id, params);
-  }
-
-  async setup () {}
 }

package/src/sort.ts

@@ -1,110 +1,130 @@
 // Sorting algorithm taken from NeDB (https://github.com/louischatriot/nedb)
 // See https://github.com/louischatriot/nedb/blob/e3f0078499aa1005a59d0c2372e425ab789145c1/lib/model.js#L189
 
-export function compareNSB (a: any, b: any) {
-  if (a < b) { return -1; }
-  if (a > b) { return 1; }
-  return 0;
+export function compareNSB(a: any, b: any) {
+  if (a < b) {
+    return -1
+  }
+  if (a > b) {
+    return 1
+  }
+  return 0
 }
 
-export function compareArrays (a: any, b: any) {
-  let i;
-  let comp;
-
-  for (i = 0; i < Math.min(a.length, b.length); i += 1) {
-    comp = exports.compare(a[i], b[i]);
+export function compareArrays(a: any[], b: any[]) {
+  for (let i = 0, l = Math.min(a.length, b.length); i < l; i++) {
+    const comparison = compare(a[i], b[i])
 
-    if (comp !== 0) { return comp; }
+    if (comparison !== 0) {
+      return comparison
+    }
   }
 
   // Common section was identical, longest one wins
-  return exports.compareNSB(a.length, b.length);
+  return compareNSB(a.length, b.length)
 }
 
-export function compare (a: any, b: any, compareStrings: any = exports.compareNSB) {
-  const { compareNSB, compare, compareArrays } = exports;
+export function compare(a: any, b: any, compareStrings: any = compareNSB): 0 | 1 | -1 {
+  if (a === b) {
+    return 0
+  }
 
   // undefined
-  if (a === undefined) { return b === undefined ? 0 : -1; }
-  if (b === undefined) { return a === undefined ? 0 : 1; }
+  if (a === undefined) {
+    return -1
+  }
+  if (b === undefined) {
+    return 1
+  }
 
   // null
-  if (a === null) { return b === null ? 0 : -1; }
-  if (b === null) { return a === null ? 0 : 1; }
+  if (a === null) {
+    return -1
+  }
+  if (b === null) {
+    return 1
+  }
 
   // Numbers
-  if (typeof a === 'number') { return typeof b === 'number' ? compareNSB(a, b) : -1; }
-  if (typeof b === 'number') { return typeof a === 'number' ? compareNSB(a, b) : 1; }
+  if (typeof a === 'number') {
+    return typeof b === 'number' ? compareNSB(a, b) : -1
+  }
+  if (typeof b === 'number') {
+    return 1
+  }
 
   // Strings
-  if (typeof a === 'string') { return typeof b === 'string' ? compareStrings(a, b) : -1; }
-  if (typeof b === 'string') { return typeof a === 'string' ? compareStrings(a, b) : 1; }
+  if (typeof a === 'string') {
+    return typeof b === 'string' ? compareStrings(a, b) : -1
+  }
+  if (typeof b === 'string') {
+    return 1
+  }
 
   // Booleans
-  if (typeof a === 'boolean') { return typeof b === 'boolean' ? compareNSB(a, b) : -1; }
-  if (typeof b === 'boolean') { return typeof a === 'boolean' ? compareNSB(a, b) : 1; }
+  if (typeof a === 'boolean') {
+    return typeof b === 'boolean' ? compareNSB(a, b) : -1
+  }
+  if (typeof b === 'boolean') {
+    return 1
+  }
 
   // Dates
-  if (a instanceof Date) { return b instanceof Date ? compareNSB(a.getTime(), b.getTime()) : -1; }
-  if (b instanceof Date) { return a instanceof Date ? compareNSB(a.getTime(), b.getTime()) : 1; }
+  if (a instanceof Date) {
+    return b instanceof Date ? compareNSB(a.getTime(), b.getTime()) : -1
+  }
+  if (b instanceof Date) {
+    return 1
+  }
 
   // Arrays (first element is most significant and so on)
-  if (Array.isArray(a)) { return Array.isArray(b) ? compareArrays(a, b) : -1; }
-  if (Array.isArray(b)) { return Array.isArray(a) ? compareArrays(a, b) : 1; }
+  if (Array.isArray(a)) {
+    return Array.isArray(b) ? compareArrays(a, b) : -1
+  }
+  if (Array.isArray(b)) {
+    return 1
+  }
 
   // Objects
-  const aKeys = Object.keys(a).sort();
-  const bKeys = Object.keys(b).sort();
-  let comp = 0;
+  const aKeys = Object.keys(a).sort()
+  const bKeys = Object.keys(b).sort()
 
-  for (let i = 0; i < Math.min(aKeys.length, bKeys.length); i += 1) {
-    comp = compare(a[aKeys[i]], b[bKeys[i]]);
+  for (let i = 0, l = Math.min(aKeys.length, bKeys.length); i < l; i++) {
+    const comparison = compare(a[aKeys[i]], b[bKeys[i]])
 
-    if (comp !== 0) { return comp; }
+    if (comparison !== 0) {
+      return comparison
+    }
   }
 
-  return compareNSB(aKeys.length, bKeys.length);
+  return compareNSB(aKeys.length, bKeys.length)
 }
 
 // An in-memory sorting function according to the
 // $sort special query parameter
-export function sorter ($sort: any) {
-  let sortLevels = false; // True if $sort has tags with '.' i.e. '{a: 1, b: -1, "c.x.z": 1}'
-
-  const getVal = (a: any, sortKeys: any[]) => {
-    let keys = sortKeys.map(key => key);
-    let val = a;
-    do {
-      let key = keys.shift();
-      val = val[key];
-    } while (keys.length);
-  
-    return val;
-  };
-  
-    const criteria = Object.keys($sort).map(key => {
-      const direction = $sort[key];
-      const keys = key.split('.');
-      sortLevels = keys.length > 1;
-
-      return { keys, direction };
-    });
+export function sorter($sort: { [key: string]: -1 | 1 }) {
+  const get = (value: any, path: string[]) => path.reduce((value, key) => value[key], value)
 
-  return function (a: any, b: any) {
-    let compare;
+  const compares = Object.keys($sort).map((key) => {
+    const direction = $sort[key]
+    const path = key.split('.')
 
-    for (const criterion of criteria) {
-    if (sortLevels) {
-      compare = criterion.direction * exports.compare(getVal(a, criterion.keys), getVal(b, criterion.keys));
+    if (path.length === 1) {
+      return (a: any, b: any) => direction * compare(a[key], b[key])
     } else {
-      compare = criterion.direction * exports.compare(a[criterion.keys[0]], b[criterion.keys[0]]);
+      return (a: any, b: any) => direction * compare(get(a, path), get(b, path))
     }
+  })
 
-      if (compare !== 0) {
-        return compare;
+  return function (a: any, b: any) {
+    for (const compare of compares) {
+      const comparasion = compare(a, b)
+
+      if (comparasion !== 0) {
+        return comparasion
       }
     }
 
-    return 0;
-  };
+    return 0
+  }
 }

package/lib/filter-query.d.ts

@@ -1,10 +0,0 @@
-export declare const FILTERS: {
-    $sort: (value: any) => any;
-    $limit: (value: any, options: any) => any;
-    $skip: (value: any) => number;
-    $select: (value: any) => any;
-};
-export declare const OPERATORS: string[];
-export declare function filterQuery(query: any, options?: any): {
-    [key: string]: any;
-};