@nymphjs/client 1.0.0-beta.4 → 1.0.0-beta.40

package/src/Nymph.ts

@@ -1,15 +1,15 @@
 import Entity from './Entity';
-import {
+import type {
   EntityConstructor,
-  EntityData,
   EntityInterface,
   EntityJson,
   ServerCallResponse,
   ServerCallStaticResponse,
 } from './Entity.types';
 import EntityWeakCache from './EntityWeakCache';
+import type { AbortableAsyncIterator } from './HttpRequester';
 import HttpRequester from './HttpRequester';
-import {
+import type {
   EventType,
   NymphOptions,
   Options,
@@ -17,7 +17,7 @@ import {
   ResponseCallback,
   Selector,
 } from './Nymph.types';
-import PubSub from './PubSub';
+import type PubSub from './PubSub';
 import { entitiesToReferences, entityConstructorsToClassNames } from './utils';
 
 let requester: HttpRequester;
@@ -36,7 +36,7 @@ export default class Nymph {
   /**
    * The entity class for this instance of Nymph.
    */
-  public Entity: typeof Entity = Entity;
+  public Entity: typeof Entity;
 
   private requestCallbacks: RequestCallback[] = [];
   private responseCallbacks: ResponseCallback[] = [];
@@ -49,10 +49,7 @@ export default class Nymph {
     // @ts-ignore TS doesn't know about WeakRef.
     this.weakCache = !!NymphOptions.weakCache && typeof WeakRef !== 'undefined';
 
-    class NymphEntity<T extends EntityData = EntityData> extends Entity<T> {}
-    NymphEntity.nymph = this;
-    this.Entity = NymphEntity;
-    this.addEntityClass(NymphEntity);
+    this.Entity = this.addEntityClass(Entity);
 
     requester = new HttpRequester(
       'fetch' in NymphOptions ? NymphOptions.fetch : undefined
@@ -71,20 +68,44 @@ export default class Nymph {
     });
   }
 
-  public addEntityClass(entityClass: EntityConstructor) {
-    this.entityClasses[entityClass.class] = entityClass;
-    entityClass.nymph = this;
+  /**
+   * Add your class to this instance.
+   *
+   * This will create a class that extends your class within this instance of
+   * Nymph and return it. You can then use this class's constructor and methods,
+   * which will use this instance of Nymph.
+   *
+   * Because this creates a subclass, don't use the class
+   * returned from `getEntityClass` to check with `instanceof`.
+   */
+  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+    const nymph = this;
+    class NymphEntity extends entityClass {
+      static nymph: Nymph = nymph;
+
+      constructor(...args: any[]) {
+        super(...args);
+      }
+    }
+    this.entityClasses[entityClass.class] = NymphEntity;
+    return NymphEntity;
   }
 
-  public getEntityClass(className: string) {
-    if (this.entityClasses.hasOwnProperty(className)) {
-      const EntityClass = this.entityClasses[className];
-      EntityClass.nymph = this;
-      return EntityClass;
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
+  public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor = EntityConstructor>(
+    className: T | string
+  ): T | EntityConstructor {
+    let key: string | null = null;
+    if (typeof className === 'string') {
+      key = className;
+    } else {
+      key = className.class;
     }
-    throw new ClassNotAvailableError(
-      "Tried to get class that's not available: " + className
-    );
+    if (key in this.entityClasses) {
+      return this.entityClasses[key];
+    }
+    throw new ClassNotAvailableError('Tried to use class: ' + key);
   }
 
   public async newUID(name: string) {
@@ -291,7 +312,7 @@ export default class Nymph {
     options: Options<T>,
     ...selectors: Selector[] | string[]
   ): Promise<EntityJson<T> | string | number | null> {
-    if (options.class === this.getEntityClass('Entity')) {
+    if (options.class instanceof Entity) {
       throw new InvalidRequestError(
         "You can't make REST requests with the base Entity class."
       );
@@ -404,10 +425,7 @@ export default class Nymph {
     if (Array.isArray(item)) {
       // Recurse into lower arrays.
       return item.map((entry) => this.initEntitiesFromData(entry)) as T;
-    } else if (
-      item instanceof Object &&
-      !(item instanceof this.getEntityClass('Entity'))
-    ) {
+    } else if (item instanceof Object && !(item instanceof Entity)) {
       if (
         item.hasOwnProperty('class') &&
         item.hasOwnProperty('guid') &&
@@ -504,6 +522,43 @@ export default class Nymph {
     return this.initEntitiesFromData(data);
   }
 
+  public async serverCallStaticIterator(
+    className: string,
+    method: string,
+    params: any[]
+  ): Promise<AbortableAsyncIterator<ServerCallStaticResponse>> {
+    const iterable = await requester.POST_ITERATOR({
+      url: this.restUrl,
+      dataType: 'json',
+      data: {
+        action: 'method',
+        data: {
+          class: className,
+          static: true,
+          method: method,
+          iterator: true,
+          params: entitiesToReferences(entityConstructorsToClassNames(params)),
+        },
+      },
+    });
+
+    const that = this;
+    const iterator: AbortableAsyncIterator = {
+      abortController: iterable.abortController,
+      async *[Symbol.asyncIterator]() {
+        for await (let response of iterable) {
+          if (response instanceof Error) {
+            yield response;
+          } else {
+            yield that.initEntitiesFromData(response);
+          }
+        }
+      },
+    };
+
+    return iterator;
+  }
+
   public on<T extends EventType>(
     event: T,
     callback: T extends 'request'

package/src/Nymph.types.ts

@@ -21,6 +21,10 @@ export type NymphOptions = {
    * Whether to not output status messages to the console.
    */
   noConsole?: boolean;
+  /**
+   * Don't automatically try to connect to PubSub server.
+   */
+  noAutoconnect?: boolean;
   /**
    * Use a WeakRef based cache of entities.
    *
@@ -53,7 +57,7 @@ export type Options<T extends EntityConstructor = EntityConstructor> = {
   limit?: number;
   offset?: number;
   reverse?: boolean;
-  sort?: 'cdate' | 'mdate';
+  sort?: 'cdate' | 'mdate' | string;
   return?: 'entity' | 'guid' | 'count';
   skipCache?: boolean;
 };