@nymphjs/client 1.0.0-beta.2 → 1.0.0-beta.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nymphjs/client",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.21",
   "description": "NymphJS - Client",
   "browser": "dist/index.js",
   "main": "lib/index.js",
@@ -36,16 +36,16 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.1",
-    "@types/jest": "^29.2.3",
-    "@types/lodash": "^4.14.189",
-    "jest": "^29.3.1",
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/jest": "^29.5.1",
+    "@types/lodash": "^4.14.194",
+    "jest": "^29.5.0",
     "lodash": "^4.17.21",
-    "ts-jest": "^29.0.3",
-    "ts-loader": "^9.4.1",
-    "typescript": "^4.9.3",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^4.10.0"
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.2",
+    "typescript": "^5.0.4",
+    "webpack": "^5.80.0",
+    "webpack-cli": "^5.0.2"
   },
-  "gitHead": "431d1aaa620a4f1d4ef0227aaad717665dfd6a6d"
+  "gitHead": "a1149a055d645ce8191845978d5cbdeaa1afddaa"
 }

package/src/Entity.ts

@@ -419,9 +419,6 @@ export default class Entity<T extends EntityData = EntityData>
         return false;
       }
     }
-    if (object.constructor !== this.constructor) {
-      return false;
-    }
     if (object.cdate !== this.cdate) {
       return false;
     }
@@ -524,7 +521,7 @@ export default class Entity<T extends EntityData = EntityData>
     const mdate = this.mdate;
 
     await this.$nymph.patchEntity(this);
-    return mdate === this.mdate;
+    return mdate !== this.mdate;
   }
 
   public $ready() {

package/src/Entity.types.ts

@@ -208,7 +208,7 @@ export interface EntityInterface extends DataObjectInterface {
   $toReference(): EntityReference | EntityInterface;
 }
 
-export type EntityConstructor = (new () => EntityInterface) & {
+export type EntityConstructor = (new (...args: any[]) => EntityInterface) & {
   /**
    * The instance of Nymph to use for queries.
    */

package/src/EntityWeakCache.ts

@@ -1,15 +1,18 @@
 import { EntityConstructor, EntityInterface } from './Entity.types';
 
 export default class EntityWeakCache {
-  private references: WeakMap<EntityConstructor, { [k: string]: any }> =
-    new WeakMap();
+  private references: WeakMap<
+    EntityConstructor,
+    { [k: string]: WeakRef<EntityInterface> }
+  > = new WeakMap();
 
   get(EntityClass: EntityConstructor, guid: string): EntityInterface | null {
     const classMap = this.references.get(EntityClass);
     if (classMap && guid in classMap) {
       const weakRef = classMap[guid];
-      if (weakRef && weakRef.deref() != null) {
-        return weakRef.deref();
+      const deref = weakRef && weakRef.deref();
+      if (deref != null) {
+        return deref;
       } else {
         delete classMap[guid];
       }
@@ -22,7 +25,6 @@ export default class EntityWeakCache {
       return;
     }
 
-    // @ts-ignore TS doesn't know about WeakRef.
     const weakRef = new WeakRef(entity);
 
     const classMap = this.references.get(EntityClass) || {};

package/src/HttpRequester.ts

@@ -167,9 +167,15 @@ export default class HttpRequester {
         };
       }
       errObj.status = response.status;
-      throw response.status < 500
-        ? new ClientError(errObj)
-        : new ServerError(errObj);
+      throw response.status < 200
+        ? new InformationalError(response, errObj)
+        : response.status < 300
+        ? new SuccessError(response, errObj)
+        : response.status < 400
+        ? new RedirectError(response, errObj)
+        : response.status < 500
+        ? new ClientError(response, errObj)
+        : new ServerError(response, errObj);
     }
     for (let i = 0; i < this.responseCallbacks.length; i++) {
       this.responseCallbacks[i] &&
@@ -202,18 +208,49 @@ export class InvalidResponseError extends Error {
   }
 }
 
-export class ClientError extends Error {
-  constructor(errObj: { textStatus: string }) {
+export class HttpError extends Error {
+  status: number;
+  statusText: string;
+
+  constructor(
+    name: string,
+    response: Response,
+    errObj: { textStatus: string }
+  ) {
     super(errObj.textStatus);
-    this.name = 'ClientError';
+    this.name = name;
+    this.status = response.status;
+    this.statusText = response.statusText;
     Object.assign(this, errObj);
   }
 }
 
-export class ServerError extends Error {
-  constructor(errObj: { textStatus: string }) {
-    super(errObj.textStatus);
-    this.name = 'ServerError';
-    Object.assign(this, errObj);
+export class InformationalError extends HttpError {
+  constructor(response: Response, errObj: { textStatus: string }) {
+    super('InformationalError', response, errObj);
+  }
+}
+
+export class SuccessError extends HttpError {
+  constructor(response: Response, errObj: { textStatus: string }) {
+    super('SuccessError', response, errObj);
+  }
+}
+
+export class RedirectError extends HttpError {
+  constructor(response: Response, errObj: { textStatus: string }) {
+    super('RedirectError', response, errObj);
+  }
+}
+
+export class ClientError extends HttpError {
+  constructor(response: Response, errObj: { textStatus: string }) {
+    super('ClientError', response, errObj);
+  }
+}
+
+export class ServerError extends HttpError {
+  constructor(response: Response, errObj: { textStatus: string }) {
+    super('ServerError', response, errObj);
   }
 }

package/src/Nymph.ts

@@ -1,7 +1,6 @@
 import Entity from './Entity';
-import {
+import type {
   EntityConstructor,
-  EntityData,
   EntityInterface,
   EntityJson,
   ServerCallResponse,
@@ -9,7 +8,7 @@ import {
 } from './Entity.types';
 import EntityWeakCache from './EntityWeakCache';
 import HttpRequester from './HttpRequester';
-import {
+import type {
   EventType,
   NymphOptions,
   Options,
@@ -17,7 +16,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 +35,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 +48,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,16 +67,32 @@ 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;
+    if (className in this.entityClasses) {
+      return this.entityClasses[className];
     }
     throw new ClassNotAvailableError(
       "Tried to get class that's not available: " + className

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;
 };

package/src/PubSub.ts

@@ -14,10 +14,10 @@ import {
 } from './PubSub.types';
 import { entityConstructorsToClassNames } from './utils';
 
-let authToken: string | null = null;
-
 export default class PubSub {
   private nymph: Nymph;
+  private authToken: string | null = null;
+  private switchToken: string | null = null;
   private connection: WebSocket | undefined;
   private waitForConnectionTimeout: NodeJS.Timeout | undefined;
   private pubsubUrl: string | undefined;
@@ -51,7 +51,10 @@ export default class PubSub {
     if (typeof addEventListener !== 'undefined') {
       addEventListener('online', () => this.connect());
     }
-    if (typeof navigator === 'undefined' || navigator.onLine) {
+    if (
+      !nymphOptions.noAutoconnect &&
+      (typeof navigator === 'undefined' || navigator.onLine)
+    ) {
       this.connect();
     }
   }
@@ -289,10 +292,11 @@ export default class PubSub {
       }
     }
 
-    if (authToken != null) {
+    if (this.authToken != null) {
       this._send({
         action: 'authenticate',
-        token: authToken,
+        token: this.authToken,
+        switchToken: this.switchToken,
       });
     }
 
@@ -645,8 +649,7 @@ export default class PubSub {
       const query = JSON.parse(update.query);
       if (entity != null) {
         // Insert the entity in order.
-        const sort =
-          'sort' in query[0] ? (query[0].sort as 'cdate' | 'mdate') : 'cdate';
+        const sort = 'sort' in query[0] ? (query[0].sort as string) : 'cdate';
         const reverse = query[0].hasOwnProperty('reverse')
           ? query[0].reverse
           : false;
@@ -716,12 +719,14 @@ export default class PubSub {
     return true;
   }
 
-  public setToken(token: string | null) {
-    authToken = token;
+  public setToken(authToken: string | null, switchToken: string | null = null) {
+    this.authToken = authToken;
+    this.switchToken = switchToken;
     if (this.isConnectionOpen()) {
       this._send({
         action: 'authenticate',
-        token: authToken,
+        authToken: this.authToken,
+        switchToken: this.switchToken,
       });
     }
   }