@vsaas/loopback-datasource-juggler 10.0.0

package/types/relation.d.ts

@@ -0,0 +1,301 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { AnyObject, Callback, Options, PromiseOrVoid } from './common';
+import { ModelData } from './model';
+import { Count, PersistedData, PersistedModel, PersistedModelClass } from './persisted-model';
+import { Filter, Where } from './query';
+
+/**
+ * Relation types
+ */
+export enum RelationType {
+  belongsTo = 'belongsTo',
+  hasMany = 'hasMany',
+  hasOne = 'hasOne',
+  hasAndBelongsToMany = 'hasAndBelongsToMany',
+  referencesMany = 'referencesMany',
+  embedsOne = 'embedsOne',
+  embedsMany = 'embedsMany',
+}
+
+/**
+ * Relation definition
+ */
+export declare class RelationDefinition {
+  name: string;
+  type: RelationType;
+  modelFrom: PersistedModelClass | string;
+  keyFrom: string;
+  modelTo: PersistedModelClass | string;
+  keyTo: string;
+  polymorphic: AnyObject | boolean;
+  modelThrough?: PersistedModelClass | string;
+  keyThrough?: string;
+  multiple: boolean;
+  properties: AnyObject;
+  options: Options;
+  scope: AnyObject;
+  embed?: boolean;
+  methods?: AnyObject<Function>;
+
+  toJSON(): AnyObject;
+  defineMethod(name: string, fn: Function): Function;
+  applyScope(modelInstance: PersistedData, filter: Filter): void;
+  applyProperties(modelInstance: PersistedData, obj: AnyObject): void;
+}
+
+/**
+ * Relation of a given model instance
+ */
+export declare class Relation<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> {
+  constructor(definition: RelationDefinition, modelInstance: S);
+
+  resetCache(cache: T): void;
+  getCache(): AnyObject<T>;
+  callScopeMethod(methodName: string, ...args: any[]): any;
+  fetch(
+    condOrRefresh: boolean | AnyObject,
+    options?: Options,
+    callback?: Callback<T | T[]>,
+  ): PromiseOrVoid<T | T[]>;
+}
+
+export declare class BelongsTo<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  create(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  build(targetModelData: PersistedData<T>): T;
+
+  update(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroy(options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  related(
+    condOrRefresh: boolean | AnyObject,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  get(options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+}
+
+export declare class HasMany<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  removeFromCache(id: any): T | null;
+
+  addToCache(inst: T): void;
+
+  findById(fkId: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  exists(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  updateById(
+    fkId: any,
+    data: ModelData,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroyById(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+}
+
+export declare class HasManyThrough<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  findById(fkId: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  destroyById(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  create(data: PersistedData<T>, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  add(
+    acInst: any,
+    data: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  exists(acInst: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  remove(acInst: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+}
+
+export declare class HasOne<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  create(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  update(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroy(options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  build(targetModelData: PersistedData<T>): T;
+
+  related(condOrRefresh: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  get(options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+}
+
+export declare class HasAndBelongsToMany<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {}
+
+export declare class ReferencesMany<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  related(
+    receiver: PersistedModelClass,
+    scopeParams: AnyObject,
+    condOrRefresh: any,
+    options?: Options,
+    callback?: Callback<ModelData>,
+  ): PromiseOrVoid<ModelData>;
+
+  findById(fkId: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  exists(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  updateById(
+    fkId: any,
+    data: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroyById(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  at(index: number, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  create(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  build(targetModelData: PersistedData<T>): T;
+
+  add(acInst: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  remove(acInst: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+}
+
+export declare class EmbedsOne<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  related(condOrRefresh: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  prepareEmbeddedInstance(inst: T): void;
+
+  embeddedValue(modelInstance: S): T;
+
+  create(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  build(targetModelData: PersistedData<T>): T;
+
+  update(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroy(options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+}
+
+export declare class EmbedsMany<
+  S extends PersistedModel = PersistedModel,
+  T extends PersistedModel = PersistedModel,
+> extends Relation<S, T> {
+  prepareEmbeddedInstance(inst: T): void;
+
+  embeddedList(modelInstance: T[]): void;
+
+  embeddedValue(modelInstance: S): T[];
+
+  related(
+    receiver: PersistedModelClass,
+    scopeParams: AnyObject,
+    condOrRefresh: any,
+    options?: Options,
+    callback?: Callback<ModelData>,
+  ): PromiseOrVoid<ModelData>;
+
+  findById(fkId: any, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  get(fkId: any, options?: Options, callback?: Callback<ModelData>): PromiseOrVoid<ModelData>;
+
+  exists(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  updateById(
+    fkId: any,
+    data: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  set(
+    fkId: any,
+    data: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  destroyById(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  unset(fkId: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+
+  destroyAll(where: Where, options?: Options, callback?: Callback<Count>): PromiseOrVoid<Count>;
+
+  at(index: number, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  create(
+    targetModelData: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<T>,
+  ): PromiseOrVoid<T>;
+
+  build(targetModelData: PersistedData<T>): T;
+
+  add(
+    acInst: any,
+    data: PersistedData<T>,
+    options?: Options,
+    callback?: Callback<boolean>,
+  ): PromiseOrVoid<boolean>;
+
+  remove(acInst: any, options?: Options, callback?: Callback<boolean>): PromiseOrVoid<boolean>;
+}

package/types/scope.d.ts

@@ -0,0 +1,92 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { AnyObject, Callback, Options, PromiseOrVoid } from './common';
+import { ModelBase, ModelBaseClass, ModelData } from './model';
+import { Count } from './persisted-model';
+import { Filter, Where } from './query';
+
+/**
+ * Definition metadata for scopes
+ */
+export declare class ScopeDefinition {
+  constructor(definition: AnyObject);
+
+  isStatic: boolean;
+  modelFrom?: ModelBaseClass;
+  modelTo?: ModelBaseClass;
+  name: string;
+  params?: AnyObject;
+  methods?: AnyObject<Function>;
+  options?: Options;
+
+  targetModel(receiver: ModelBaseClass | (() => ModelBaseClass)): void;
+
+  /**
+   * Find related model instances
+   * @param {*} receiver The target model class/prototype
+   * @param {Object|Function} scopeParams
+   * @param {Boolean|Object} [condOrRefresh] true for refresh or object as a filter
+   * @param {Object} [options]
+   * @param {Function} cb
+   * @returns {*}
+   */
+  related(
+    receiver: ModelBaseClass | (() => ModelBaseClass),
+    scopeParams: AnyObject | (() => AnyObject),
+    condOrRefresh: boolean | AnyObject,
+    options?: Options,
+    callback?: Callback,
+  ): PromiseOrVoid;
+
+  /**
+   * Define a scope method
+   * @param {String} name of the method
+   * @param {Function} function to define
+   */
+  defineMethod(name: string, fn: Function): Function;
+}
+
+/**
+ * Define a scope to the class
+ * @param {Model} cls The class where the scope method is added
+ * @param {Model} targetClass The class that a query to run against
+ * @param {String} name The name of the scope
+ * @param {Object|Function} params The parameters object for the query or a function
+ * to return the query object
+ * @param methods An object of methods keyed by the method name to be bound to the class
+ */
+export declare function defineScope(
+  cls: ModelBaseClass,
+  targetClass: ModelBaseClass,
+  name: string,
+  params: AnyObject,
+  methods: AnyObject<Function>,
+  options?: Options,
+): ScopeDefinition;
+
+/**
+ * Methods injected by scopes
+ */
+export interface ScopedMethods<T extends ModelBase = ModelBase> {
+  build(data: ModelData<T>): T;
+
+  create(data: ModelData<T>, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  destroyAll(where?: Where, options?: Options, callback?: Callback<Count>): PromiseOrVoid<Count>;
+
+  updateAll(
+    where?: Where,
+    data?: ModelData<T>,
+    options?: Options,
+    callback?: Callback<Count>,
+  ): PromiseOrVoid<Count>;
+
+  findById(id: any, filter: Filter, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  findOne(filter: Filter, options?: Options, callback?: Callback<T>): PromiseOrVoid<T>;
+
+  count(where: Where, options?: Options, callback?: Callback<number>): PromiseOrVoid<number>;
+}

package/types/transaction-mixin.d.ts

@@ -0,0 +1,47 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { Callback, Options, PromiseOrVoid } from './common';
+
+/**
+ * Local transaction
+ */
+export interface Transaction {
+  /**
+   * Commit the transaction
+   * @param callback
+   */
+  commit(callback?: Callback): PromiseOrVoid;
+  /**
+   * Rollback the transaction
+   * @param callback
+   */
+  rollback(callback?: Callback): PromiseOrVoid;
+}
+
+/**
+ * Isolation level
+ */
+export enum IsolationLevel {
+  READ_COMMITTED = 'READ COMMITTED', // default
+  READ_UNCOMMITTED = 'READ UNCOMMITTED',
+  SERIALIZABLE = 'SERIALIZABLE',
+  REPEATABLE_READ = 'REPEATABLE READ',
+}
+
+/**
+ * Mixin for transaction support
+ */
+export interface TransactionMixin {
+  /**
+   * Begin a new transaction
+   * @param options
+   * @param callback
+   */
+  beginTransaction(
+    options?: IsolationLevel | Options,
+    callback?: Callback<Transaction>,
+  ): PromiseOrVoid<Transaction>;
+}

package/types/types.d.ts

@@ -0,0 +1,65 @@
+import { DateString } from './date-string';
+
+// @achrinza: The return value is a hack to inform TypeScript of function parameter mutations.
+//            see: https://github.com/microsoft/TypeScript/issues/22865#issuecomment-725015710
+declare function registerModelTypes(
+  modelTypes: registerModelTypes.ModelTypes,
+): asserts modelTypes is registerModelTypes.BuiltModelTypes;
+
+declare namespace registerModelTypes {
+  // @achrinza: One of the limitations of these definitions is that the class instance
+  //            isn't callable; Hence, changing the `value` class member must be done
+  //            directly. This is a TypeScript limitation as class constructors cannot
+  //            have a custom return value.
+  namespace Types {
+    function Text<T extends unknown>(value: T): T extends Text ? void : T;
+    class Text implements Type {
+      value: Text;
+      constructor(value: Text);
+      toJSON(): Text;
+      toObject(): Text;
+    }
+
+    function JSON<T extends unknown>(value: T): T extends JSON ? void : T;
+    class JSON implements Type {
+      value: unknown;
+      constructor(value: unknown);
+      toJSON(): unknown;
+      toObject(): unknown;
+    }
+
+    function Any<T extends unknown>(value: T): T extends Any ? void : T;
+    class Any implements Type {
+      value: unknown;
+      constructor(value: unknown);
+      toJSON(): unknown;
+      toObject(): unknown;
+    }
+  }
+
+  interface ModelTypes {
+    [type: string]: Type | unknown;
+  }
+
+  interface Type {
+    value: unknown;
+    toJSON(): unknown;
+    toObject(): unknown;
+  }
+
+  interface BuiltModelTypes extends ModelTypes {
+    schemaTypes: Record<string, Type> & {
+      String: String;
+      Number: Number;
+      Date: Date;
+      DateString: DateString;
+      Binary: Buffer;
+      Buffer: Buffer;
+      Array: Array<unknown>;
+      Object: Object;
+      // 'GeoPoint': GeoPoint // Removed temporarily. See: https://github.com/loopbackio/loopback-datasource-juggler/issues/1909
+    };
+    registerType: (type: Type, names?: string[]) => void;
+  }
+}
+export = registerModelTypes;