@nymphjs/client 1.0.0-alpha.2 → 1.0.0-alpha.23

package/src/Nymph.ts

@@ -1,10 +1,13 @@
+import Entity from './Entity';
 import {
   EntityConstructor,
+  EntityData,
   EntityInterface,
   EntityJson,
   ServerCallResponse,
   ServerCallStaticResponse,
 } from './Entity.types';
+import EntityWeakCache from './EntityWeakCache';
 import HttpRequester from './HttpRequester';
 import {
   EventType,
@@ -14,34 +17,42 @@ import {
   ResponseCallback,
   Selector,
 } from './Nymph.types';
+import PubSub from './PubSub';
 import { entitiesToReferences, entityConstructorsToClassNames } from './utils';
 
 let requester: HttpRequester;
 
 export default class Nymph {
-  private static entityClasses: { [k: string]: EntityConstructor } = {};
-  private static requestCallbacks: RequestCallback[] = [];
-  private static responseCallbacks: ResponseCallback[] = [];
-  private static restUrl: string;
-
-  public static setEntityClass(
-    className: string,
-    entityClass: EntityConstructor
-  ) {
-    this.entityClasses[className] = entityClass;
-  }
-
-  public static getEntityClass(className: string) {
-    if (this.entityClasses.hasOwnProperty(className)) {
-      return this.entityClasses[className];
-    }
-    throw new ClassNotAvailableError(
-      "Tried to get class that's not available: " + className
-    );
-  }
-
-  public static init(NymphOptions: NymphOptions) {
+  /**
+   * And optional PubSub client instance.
+   */
+  public pubsub: PubSub | undefined = undefined;
+
+  /**
+   * A simple map of names to Entity classes.
+   */
+  private entityClasses: { [k: string]: EntityConstructor } = {};
+
+  /**
+   * The entity class for this instance of Nymph.
+   */
+  public Entity: typeof Entity = Entity;
+
+  private requestCallbacks: RequestCallback[] = [];
+  private responseCallbacks: ResponseCallback[] = [];
+  private restUrl: string = '';
+  private weakCache = false;
+  public cache = new EntityWeakCache();
+
+  public constructor(NymphOptions: NymphOptions) {
     this.restUrl = NymphOptions.restUrl;
+    // @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);
 
     requester = new HttpRequester(
       'fetch' in NymphOptions ? NymphOptions.fetch : undefined
@@ -60,7 +71,23 @@ export default class Nymph {
     });
   }
 
-  public static async newUID(name: string) {
+  public addEntityClass(entityClass: EntityConstructor) {
+    this.entityClasses[entityClass.class] = entityClass;
+    entityClass.nymph = this;
+  }
+
+  public getEntityClass(className: string) {
+    if (this.entityClasses.hasOwnProperty(className)) {
+      const EntityClass = this.entityClasses[className];
+      EntityClass.nymph = this;
+      return EntityClass;
+    }
+    throw new ClassNotAvailableError(
+      "Tried to get class that's not available: " + className
+    );
+  }
+
+  public async newUID(name: string) {
     const data = await requester.POST({
       url: this.restUrl,
       dataType: 'text',
@@ -69,7 +96,7 @@ export default class Nymph {
     return Number(data);
   }
 
-  public static async setUID(name: string, value: number) {
+  public async setUID(name: string, value: number) {
     return await requester.PUT({
       url: this.restUrl,
       dataType: 'json',
@@ -77,7 +104,7 @@ export default class Nymph {
     });
   }
 
-  public static async getUID(name: string) {
+  public async getUID(name: string) {
     const data = await requester.GET({
       url: this.restUrl,
       dataType: 'text',
@@ -86,7 +113,7 @@ export default class Nymph {
     return Number(data);
   }
 
-  public static async deleteUID(name: string) {
+  public async deleteUID(name: string) {
     return await requester.DELETE({
       url: this.restUrl,
       dataType: 'text',
@@ -94,12 +121,12 @@ export default class Nymph {
     });
   }
 
-  public static async saveEntity(entity: EntityInterface) {
+  public async saveEntity(entity: EntityInterface) {
     let method: 'POST' | 'PUT' = entity.guid == null ? 'POST' : 'PUT';
     return await this.requestWithMethod(entity, method, entity, false);
   }
 
-  public static async saveEntities(entities: EntityInterface[]) {
+  public async saveEntities(entities: EntityInterface[]) {
     if (!entities.length) {
       return Promise.resolve(false);
     }
@@ -119,7 +146,7 @@ export default class Nymph {
     return await this.requestWithMethod(entities, method, entities, true);
   }
 
-  public static async patchEntity(entity: EntityInterface) {
+  public async patchEntity(entity: EntityInterface) {
     if (entity.guid == null) {
       throw new InvalidRequestError(
         "You can't patch an entity that hasn't yet been saved."
@@ -130,7 +157,7 @@ export default class Nymph {
     return await this.requestWithMethod(entity, 'PATCH', patch, false);
   }
 
-  public static async patchEntities(entities: EntityInterface[]) {
+  public async patchEntities(entities: EntityInterface[]) {
     if (!entities.length) {
       return Promise.resolve(false);
     }
@@ -147,19 +174,19 @@ export default class Nymph {
     return await this.requestWithMethod(entities, 'PATCH', patch, true);
   }
 
-  private static async requestWithMethod<T extends EntityInterface>(
+  private async requestWithMethod<T extends EntityInterface>(
     entity: T,
     method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
     data: { [k: string]: any },
     plural: false
   ): Promise<T>;
-  private static async requestWithMethod<T extends EntityInterface>(
+  private async requestWithMethod<T extends EntityInterface>(
     entity: T[],
     method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
     data: { [k: string]: any },
     plural: true
   ): Promise<T[]>;
-  private static async requestWithMethod<T extends EntityInterface>(
+  private async requestWithMethod<T extends EntityInterface>(
     entity: T | T[],
     method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
     data: { [k: string]: any },
@@ -187,33 +214,23 @@ export default class Nymph {
     throw new Error('Server error');
   }
 
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
   ): Promise<ReturnType<T['factorySync']> | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string
   ): Promise<string | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     guid: string
   ): Promise<ReturnType<T['factorySync']> | null>;
-  public static async getEntity<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[] | string[]
   ): Promise<ReturnType<T['factorySync']> | string | null> {
@@ -233,30 +250,23 @@ export default class Nymph {
     return null;
   }
 
-  public static async getEntityData<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntityData<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string | null>;
-  public static async getEntityData<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntityData<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
   ): Promise<EntityJson<T> | null>;
-  public static async getEntityData<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntityData<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     guid: string
   ): Promise<string | null>;
-  public static async getEntityData<
-    T extends EntityConstructor = EntityConstructor
-  >(options: Options<T>, guid: string): Promise<EntityJson<T> | null>;
-  public static async getEntityData<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntityData<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T>,
+    guid: string
+  ): Promise<EntityJson<T> | null>;
+  public async getEntityData<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[] | string[]
   ): Promise<EntityJson<T> | string | null> {
@@ -287,21 +297,15 @@ export default class Nymph {
     return null;
   }
 
-  public static async getEntities<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string[]>;
-  public static async getEntities<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
   ): Promise<ReturnType<T['factorySync']>[]>;
-  public static async getEntities<
-    T extends EntityConstructor = EntityConstructor
-  >(
+  public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
   ): Promise<ReturnType<T['factorySync']>[] | string[]> {
@@ -323,7 +327,7 @@ export default class Nymph {
     return data.map((e: EntityJson<T>) => this.initEntity(e));
   }
 
-  public static initEntity<T extends EntityConstructor = EntityConstructor>(
+  public initEntity<T extends EntityConstructor = EntityConstructor>(
     entityJSON: EntityJson<T>
   ): ReturnType<T['factorySync']> {
     const EntityClass = this.getEntityClass(entityJSON.class);
@@ -332,11 +336,43 @@ export default class Nymph {
         entityJSON.class + ' class cannot be found.'
       );
     }
-    const entity = EntityClass.factorySync();
+    let entity = EntityClass.factorySync();
+    if (this.weakCache) {
+      // Try to get it from cache.
+      const entityFromCache = this.cache.get(
+        EntityClass,
+        entityJSON.guid || ''
+      );
+      if (entityFromCache != null) {
+        entity = entityFromCache;
+      }
+    }
     return entity.$init(entityJSON) as ReturnType<T['factorySync']>;
   }
 
-  public static initEntitiesFromData<T extends any>(item: T): T {
+  public getEntityFromCache<T extends EntityConstructor = EntityConstructor>(
+    EntityClass: EntityConstructor,
+    guid: string
+  ): ReturnType<T['factorySync']> | null {
+    if (!this.weakCache) {
+      return null;
+    }
+    return this.cache.get(EntityClass, guid) as ReturnType<
+      T['factorySync']
+    > | null;
+  }
+
+  public setEntityToCache(
+    EntityClass: EntityConstructor,
+    entity: EntityInterface
+  ) {
+    if (!this.weakCache) {
+      return;
+    }
+    return this.cache.set(EntityClass, entity);
+  }
+
+  public initEntitiesFromData<T extends any>(item: T): T {
     if (Array.isArray(item)) {
       // Recurse into lower arrays.
       return item.map((entry) => this.initEntitiesFromData(entry)) as T;
@@ -365,7 +401,7 @@ export default class Nymph {
     return item;
   }
 
-  public static async deleteEntity(
+  public async deleteEntity(
     entity: EntityInterface | EntityInterface[],
     _plural = false
   ) {
@@ -388,11 +424,11 @@ export default class Nymph {
     });
   }
 
-  public static async deleteEntities(entities: EntityInterface[]) {
+  public async deleteEntities(entities: EntityInterface[]) {
     return await this.deleteEntity(entities, true);
   }
 
-  public static async serverCall(
+  public async serverCall(
     entity: EntityInterface,
     method: string,
     params: any[],
@@ -418,7 +454,7 @@ export default class Nymph {
     };
   }
 
-  public static async serverCallStatic(
+  public async serverCallStatic(
     className: string,
     method: string,
     params: any[]
@@ -440,7 +476,7 @@ export default class Nymph {
     return this.initEntitiesFromData(data);
   }
 
-  public static on<T extends EventType>(
+  public on<T extends EventType>(
     event: T,
     callback: T extends 'request'
       ? RequestCallback
@@ -461,7 +497,7 @@ export default class Nymph {
     return () => this.off(event, callback);
   }
 
-  public static off<T extends EventType>(
+  public off<T extends EventType>(
     event: T,
     callback: T extends 'request'
       ? RequestCallback
@@ -486,7 +522,7 @@ export default class Nymph {
     return true;
   }
 
-  public static setXsrfToken(token: string | null) {
+  public setXsrfToken(token: string | null) {
     requester.setXsrfToken(token);
   }
 }
@@ -504,19 +540,3 @@ export class InvalidRequestError extends Error {
     this.name = 'InvalidRequestError';
   }
 }
-
-((global) => {
-  if (
-    typeof global !== 'undefined' &&
-    typeof (global as any as { NymphOptions: NymphOptions }).NymphOptions !==
-      'undefined'
-  ) {
-    Nymph.init((global as any as { NymphOptions: NymphOptions }).NymphOptions);
-  }
-})(
-  typeof window === 'undefined'
-    ? typeof self === 'undefined'
-      ? undefined
-      : self
-    : window
-);

package/src/Nymph.types.ts

@@ -21,6 +21,25 @@ export type NymphOptions = {
    * Whether to not output status messages to the console.
    */
   noConsole?: boolean;
+  /**
+   * Use a WeakRef based cache of entities.
+   *
+   * This ensures all entities returned are the same instance if they have the
+   * same class and GUID. This also means that whenever an entity is returned
+   * from the server, the single instance in memory will be refreshed. This
+   * could have annoying results, like destroying dirty data (the dreaded
+   * triple-D).
+   *
+   * This could also be a potential source of memory leaks. Although the
+   * entities themselves are referenced weakly so they get garbage collected,
+   * the GUID used as a key and the WeakRef object itself are not weak
+   * references, so not destroyed when the instance is garbage collected.
+   *
+   * However, even with these caveats, this might help you if you have a big app
+   * with the same entities stored in several different places in memory. This
+   * can help to synchronize them correctly and avoid data conflicts.
+   */
+  weakCache?: boolean;
 };
 
 export type EventType = 'request' | 'response';