@loopback/repository 4.0.0-alpha.8 → 4.1.0

package/src/repositories/constraint-utils.ts

@@ -0,0 +1,98 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Filter, FilterBuilder, Where, WhereBuilder} from '@loopback/filter';
+import {cloneDeep} from 'lodash';
+import {AnyObject, DataObject} from '../common-types';
+import {Entity} from '../model';
+
+/**
+ * A utility function which takes a filter and enforces constraint(s)
+ * on it
+ * @param originalFilter - the filter to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the filter
+ * @returns Filter the modified filter with the constraint, otherwise
+ * the original filter
+ */
+export function constrainFilter<T extends object>(
+  originalFilter: Filter<T> | undefined,
+  constraint: AnyObject,
+): Filter<T> {
+  const filter = cloneDeep(originalFilter);
+  const builder = new FilterBuilder<T>(filter);
+  return builder.impose(constraint).build();
+}
+
+/**
+ * A utility function which takes a where filter and enforces constraint(s)
+ * on it
+ * @param originalWhere - the where filter to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the filter
+ * @returns Filter the modified filter with the constraint, otherwise
+ * the original filter
+ */
+export function constrainWhere<T extends object>(
+  originalWhere: Where<T> | undefined,
+  constraint: Where<T>,
+): Where<T> {
+  const where = cloneDeep(originalWhere);
+  const builder = new WhereBuilder<T>(where);
+  return builder.impose(constraint).build();
+}
+/**
+ * A utility function which takes a where filter and enforces constraint(s)
+ * on it with OR clause
+ * @param originalWhere - the where filter to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the filter with
+ * or clause
+ * @returns Filter the modified filter with the constraint, otherwise
+ * the original filter
+ */
+export function constrainWhereOr<T extends object>(
+  originalWhere: Where<T> | undefined,
+  constraint: Where<T>[],
+): Where<T> {
+  const where = cloneDeep(originalWhere);
+  const builder = new WhereBuilder<T>(where);
+  return builder.or(constraint).build();
+}
+/**
+ * A utility function which takes a model instance data and enforces constraint(s)
+ * on it
+ * @param originalData - the model data to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the data object
+ * @returns the modified data with the constraint, otherwise
+ * the original instance data
+ */
+export function constrainDataObject<T extends Entity>(
+  originalData: DataObject<T>,
+  constraint: DataObject<T>,
+): DataObject<T> {
+  const constrainedData = cloneDeep(originalData);
+  for (const c in constraint) {
+    if (Object.prototype.hasOwnProperty.call(constrainedData, c)) {
+      // Known limitation: === does not work for objects such as ObjectId
+      if (originalData[c] === constraint[c]) continue;
+      throw new Error(`Property "${c}" cannot be changed!`);
+    }
+    (constrainedData as AnyObject)[c] = constraint[c];
+  }
+  return constrainedData;
+}
+
+/**
+ * A utility function which takes an array of model instance data and
+ * enforces constraint(s) on it
+ * @param originalData - the array of model data to apply the constrain(s) to
+ * @param constraint - the constraint which is to be applied on the data objects
+ * @returns an array of the modified data with the constraint, otherwise
+ * the original instance data array
+ */
+export function constrainDataObjects<T extends Entity>(
+  originalData: DataObject<T>[],
+  constraint: DataObject<T>,
+): DataObject<T>[] {
+  return originalData.map(obj => constrainDataObject(obj, constraint));
+}

package/src/repositories/index.ts

@@ -0,0 +1,10 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './kv.repository';
+export * from './legacy-juggler-bridge';
+export * from './kv.repository.bridge';
+export * from './repository';
+export * from './constraint-utils';

package/src/repositories/kv.repository.bridge.ts

@@ -0,0 +1,97 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import legacy from 'loopback-datasource-juggler';
+import {DataObject, Options} from '../common-types';
+import {Model} from '../model';
+import {KeyValueFilter, KeyValueRepository} from './kv.repository';
+import {ensurePromise, juggler} from './legacy-juggler-bridge';
+
+/**
+ * An implementation of KeyValueRepository based on loopback-datasource-juggler
+ */
+export class DefaultKeyValueRepository<T extends Model>
+  implements KeyValueRepository<T>
+{
+  /**
+   * A legacy KeyValueModel class
+   */
+  kvModelClass: typeof juggler.KeyValueModel;
+
+  /**
+   * Construct a KeyValueRepository with a legacy DataSource
+   * @param ds - Legacy DataSource
+   */
+  constructor(
+    private entityClass: typeof Model & {prototype: T},
+    ds: juggler.DataSource,
+  ) {
+    // KVModel class is placeholder to receive methods from KeyValueAccessObject
+    // through mixin
+    this.kvModelClass =
+      ds.createModel<typeof juggler.KeyValueModel>('_kvModel');
+  }
+
+  delete(key: string, options?: Options): Promise<void> {
+    return ensurePromise(this.kvModelClass.delete(key, options));
+  }
+
+  deleteAll(options?: Options): Promise<void> {
+    return ensurePromise(this.kvModelClass.deleteAll(options));
+  }
+
+  protected toEntity(modelData: legacy.ModelData): T {
+    if (modelData == null) return modelData;
+    let data = modelData;
+    if (typeof modelData.toObject === 'function') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      data = (modelData as any).toObject();
+    }
+    return new this.entityClass(data) as T;
+  }
+
+  async get(key: string, options?: Options): Promise<T> {
+    const val = this.kvModelClass.get(
+      key,
+      options,
+    ) as legacy.PromiseOrVoid<legacy.ModelData>;
+    const result = await ensurePromise(val);
+    return this.toEntity(result);
+  }
+
+  set(key: string, value: DataObject<T>, options?: Options): Promise<void> {
+    return ensurePromise<void>(this.kvModelClass.set(key, value, options));
+  }
+
+  expire(key: string, ttl: number, options?: Options): Promise<void> {
+    return ensurePromise<void>(this.kvModelClass.expire(key, ttl, options));
+  }
+
+  ttl(key: string, options?: Options): Promise<number> {
+    return ensurePromise<number>(this.kvModelClass.ttl(key, options));
+  }
+
+  keys(filter?: KeyValueFilter, options?: Options): AsyncIterable<string> {
+    const kvModelClass = this.kvModelClass;
+    const iterator = {
+      [Symbol.asyncIterator]() {
+        return new AsyncKeyIteratorImpl(
+          kvModelClass.iterateKeys(filter, options),
+        );
+      },
+    };
+    return iterator;
+  }
+}
+
+class AsyncKeyIteratorImpl implements AsyncIterator<string> {
+  constructor(private keys: legacy.AsyncKeyIterator) {}
+  next() {
+    const key = ensurePromise<string | undefined>(this.keys.next());
+    return key.then(k => {
+      return {done: k === undefined, value: k ?? ''};
+    });
+  }
+}

package/src/repositories/kv.repository.ts

@@ -0,0 +1,87 @@
+// Copyright IBM Corp. 2018,2020. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Repository} from './repository';
+import {Options, DataObject} from '../common-types';
+import {Model} from '../model';
+
+/**
+ * Filter for keys
+ */
+export type KeyValueFilter = {
+  /**
+   * Glob string to use to filter returned keys (i.e. `userid.*`). All
+   * connectors are required to support `*` and `?`. They may also support
+   * additional special characters that are specific to the backing database.
+   */
+  match: string;
+};
+
+/**
+ * Key/Value operations for connector implementations
+ */
+export interface KeyValueRepository<T extends Model> extends Repository<T> {
+  /**
+   * Delete an entry by key
+   *
+   * @param key - Key for the entry
+   * @param options - Options for the operation
+   */
+  delete(key: string, options?: Options): Promise<void>;
+
+  /**
+   * Delete all entries
+   *
+   * @param key - Key for the entry
+   * @param options - Options for the operation
+   */
+  deleteAll(options?: Options): Promise<void>;
+
+  /**
+   * Get an entry by key
+   *
+   * @param key - Key for the entry
+   * @param options - Options for the operation
+   * @returns A promise of the entry
+   */
+  get(key: string, options?: Options): Promise<T>;
+
+  /**
+   * Set an entry with key/value
+   *
+   * @param key - Key for the entry
+   * @param value - Value for the entry
+   * @param options - Options for the operation
+   */
+  set(key: string, value: DataObject<T>, options?: Options): Promise<void>;
+
+  /**
+   * Set up ttl for an entry by key
+   *
+   * @param key - Key for the entry
+   * @param ttl - Ttl for the entry
+   * @param options - Options for the operation
+   */
+  expire(key: string, ttl: number, options?: Options): Promise<void>;
+
+  /**
+   * Get ttl for an entry by key
+   *
+   * @param key - Key for the entry
+   * @param options - Options for the operation
+   * @returns A promise of the TTL value
+   */
+  ttl?(key: string, options?: Options): Promise<number>;
+
+  /**
+   * Get an Iterator for matching keys
+   *
+   * @param filter - Filter for keys
+   * @param options - Options for the operation
+   * @returns An async iteratable iterator of keys so that the return value can
+   * be used with `for-await-of`.
+   */
+  keys?(filter?: KeyValueFilter, options?: Options): AsyncIterable<string>;
+}