@nymphjs/client 1.0.0-beta.98 → 1.0.0-beta.99

package/lib/Entity.types.d.ts

@@ -0,0 +1,200 @@
+import type Nymph from './Nymph';
+import type Entity from './Entity';
+export type ServerCallResponse = {
+    return: any;
+    entity?: EntityJson;
+};
+export type ServerCallStaticResponse = any;
+export type EntityReference = ['nymph_entity_reference', string, string];
+export type EntityData = {
+    [k: string]: any;
+};
+export type SerializedEntityData = {
+    [k: string]: string;
+};
+export type EntityJson<T extends EntityConstructor = EntityConstructor> = {
+    class: T['class'];
+    guid: string | null;
+    cdate: number | null;
+    mdate: number | null;
+    tags: string[];
+    data: EntityData;
+};
+export type EntityPatch = {
+    class: string;
+    guid: string;
+    mdate: number | null;
+    set: EntityData;
+    unset: string[];
+    addTags: string[];
+    removeTags: string[];
+};
+/**
+ * Data Object interface.
+ *
+ * Objects which hold data from some type of storage.
+ */
+export interface DataObjectInterface {
+    /**
+     * Search the array for this object and return the corresponding index.
+     *
+     * If `strict` is false, `is()` is used to compare. If `strict` is true,
+     * `equals()` is used.
+     *
+     * @param array The array to search.
+     * @param strict Whether to use stronger comparison.
+     * @returns The index if the object is in the array, -1 if it isn't.
+     */
+    $arraySearch(array: any[], strict?: boolean): number;
+    /**
+     * Delete the object from storage.
+     *
+     * @returns True on success, false on failure.
+     */
+    $delete(): Promise<boolean>;
+    /**
+     * Perform a more strict comparison of this object to another.
+     *
+     * @param object The object to compare.
+     * @returns True or false.
+     */
+    $equals(object: any): boolean;
+    /**
+     * Check whether this object is in an array.
+     *
+     * If `strict` is false, `is()` is used to compare. If `strict` is true,
+     * `equals()` is used.
+     *
+     * @param array The array to search.
+     * @param strict Whether to use stronger comparison.
+     * @returns True if the object is in the array, false if it isn't.
+     */
+    $inArray(array: any[], strict?: boolean): boolean;
+    /**
+     * Perform a less strict comparison of this object to another.
+     *
+     * @param object The object to compare.
+     * @returns True or false.
+     */
+    $is(object: any): boolean;
+    /**
+     * Save the object's dirty data to storage.
+     *
+     * @returns True on success, false on failure.
+     */
+    $patch(): Promise<boolean>;
+    /**
+     * Refresh the object from storage. (Bypasses Nymph's cache.)
+     *
+     * If the object has been deleted from storage, the database cannot be
+     * reached, or a database error occurs, `refresh()` will return 0.
+     *
+     * @returns False if the data has not been saved, 0 if it can't be refreshed, true on success.
+     */
+    $refresh(): Promise<boolean | 0>;
+    /**
+     * Save the object to storage.
+     *
+     * @returns True on success, false on failure.
+     */
+    $save(): Promise<boolean>;
+    /**
+     * The object's data.
+     */
+    [k: string]: any;
+}
+/**
+ * Entity interface.
+ */
+export interface EntityInterface extends DataObjectInterface {
+    /**
+     * The instance of Nymph to use for queries.
+     */
+    $nymph: Nymph;
+    /**
+     * The entity's Globally Unique ID.
+     *
+     * This is a 12 byte number represented as a lower case HEX string (24
+     * characters).
+     */
+    guid: string | null;
+    /**
+     * The creation date of the entity as a Unix timestamp in milliseconds.
+     */
+    cdate: number | null;
+    /**
+     * The modified date of the entity as a Unix timestamp in milliseconds.
+     */
+    mdate: number | null;
+    /**
+     * Array of the entity's tags.
+     */
+    tags: string[];
+    /**
+     * Add one or more tags.
+     *
+     * @param tags List of tags.
+     */
+    $addTag(...tags: string[]): void;
+    /**
+     * Get a patch of this entity's dirty data to be applied on the server.
+     */
+    $getPatch(): EntityPatch;
+    /**
+     * Check that the entity has all of the given tags.
+     *
+     * @param tags List of tags.
+     * @returns True or false.
+     */
+    $hasTag(...tags: string[]): boolean;
+    /**
+     * Initialize this entity from a JSON representation.
+     *
+     * @param entityJson The entity JSON.
+     */
+    $init(entityJson: EntityJson | null): EntityInterface;
+    /**
+     * Retrieve this entity's data from the server.
+     *
+     * @returns The entity.
+     */
+    $wake(): Promise<EntityInterface>;
+    /**
+     * Ready this entity's data, and the data of entity's within this one's.
+     *
+     * @param level The number of levels deep to wake. If undefined, it will keep going until there are no more entities. (Careful of infinite loops.)
+     * @returns The entity.
+     */
+    $wakeAll(level?: number): Promise<EntityInterface>;
+    /**
+     * Remove one or more tags.
+     *
+     * @param tags List of tags.
+     */
+    $removeTag(...tags: string[]): void;
+    /**
+     * Call an instance method on the server version of this entity.
+     *
+     * The entity's data will be sent up to the server as well, so the server's
+     * state can match the client's state. It won't be propagated into the DB,
+     * though.
+     *
+     * @param method The name of the method.
+     * @param params The parameters to call the method with.
+     * @param stateless Whether the server should return, and the client update, the data in the entity after the method has run.
+     * @returns The value that the method on the server returned.
+     */
+    $serverCall(method: string, params: Iterable<any>, stateless: boolean): Promise<any>;
+    /**
+     * Return a Nymph Entity Reference for this entity.
+     *
+     * If the entity hasn't been saved yet (and has no GUID), it will be
+     * returned instead.
+     *
+     * @returns A Nymph Entity Reference array as an unsaved entity.
+     */
+    $toReference(): EntityReference | EntityInterface;
+}
+export type EntityConstructor<D extends EntityData = EntityData, E extends Entity<D> = Entity<D>> = (new (...args: any[]) => E) & {
+    [k in keyof typeof Entity]: (typeof Entity)[k];
+};

package/lib/Entity.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Entity.types.js.map

package/lib/Entity.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.types.js","sourceRoot":"","sources":["../src/Entity.types.ts"],"names":[],"mappings":""}

package/lib/EntityWeakCache.d.ts

@@ -0,0 +1,6 @@
+import { EntityConstructor, EntityInterface } from './Entity.types';
+export default class EntityWeakCache {
+    private references;
+    get(EntityClass: EntityConstructor, guid: string): EntityInterface | null;
+    set(EntityClass: EntityConstructor, entity: EntityInterface): void;
+}

package/lib/EntityWeakCache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EntityWeakCache {
+    constructor() {
+        this.references = new WeakMap();
+    }
+    get(EntityClass, guid) {
+        const classMap = this.references.get(EntityClass);
+        if (classMap && guid in classMap) {
+            const weakRef = classMap[guid];
+            const deref = weakRef && weakRef.deref();
+            if (deref != null) {
+                return deref;
+            }
+            else {
+                delete classMap[guid];
+            }
+        }
+        return null;
+    }
+    set(EntityClass, entity) {
+        if (!entity.guid) {
+            return;
+        }
+        const weakRef = new WeakRef(entity);
+        const classMap = this.references.get(EntityClass) || {};
+        this.references.set(EntityClass, classMap);
+        classMap[entity.guid] = weakRef;
+    }
+}
+exports.default = EntityWeakCache;
+//# sourceMappingURL=EntityWeakCache.js.map

package/lib/EntityWeakCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityWeakCache.js","sourceRoot":"","sources":["../src/EntityWeakCache.ts"],"names":[],"mappings":";;AAEA,MAAqB,eAAe;IAApC;QACU,eAAU,GAGd,IAAI,OAAO,EAAE,CAAC;IA2BpB,CAAC;IAzBC,GAAG,CAAC,WAA8B,EAAE,IAAY;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAClD,IAAI,QAAQ,IAAI,IAAI,IAAI,QAAQ,EAAE,CAAC;YACjC,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC/B,MAAM,KAAK,GAAG,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;YACzC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,OAAO,KAAK,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,GAAG,CAAC,WAA8B,EAAE,MAAuB;QACzD,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;QAEpC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QACxD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAC3C,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;IAClC,CAAC;CACF;AA/BD,kCA+BC"}

package/lib/HttpRequester.d.ts

@@ -0,0 +1,78 @@
+export type HttpRequesterEventType = 'request' | 'response';
+export type HttpRequesterRequestCallback = (requester: HttpRequester, url: string, options: RequestInit) => void;
+export type HttpRequesterResponseCallback = (requester: HttpRequester, response: Response, text: string) => void;
+export type HttpRequesterIteratorCallback = (requester: HttpRequester, url: string, headers: Record<string, string>) => void;
+export type HttpRequesterRequestOptions = {
+    url: string;
+    headers?: {
+        [k: string]: any;
+    };
+    data: {
+        [k: string]: any;
+    };
+    dataType: string;
+};
+export interface AbortableAsyncIterator<T extends any = any> extends AsyncIterable<T> {
+    abortController: AbortController;
+}
+export default class HttpRequester {
+    private fetch;
+    private requestCallbacks;
+    private responseCallbacks;
+    private iteratorCallbacks;
+    static makeUrl(url: string, data: {
+        [k: string]: any;
+    }): string;
+    constructor(ponyFetch?: WindowOrWorkerGlobalScope['fetch']);
+    on<T extends HttpRequesterEventType>(event: T, callback: T extends 'request' ? HttpRequesterRequestCallback : T extends 'response' ? HttpRequesterResponseCallback : T extends 'iterator' ? HttpRequesterIteratorCallback : never): () => boolean;
+    off<T extends HttpRequesterEventType>(event: T, callback: T extends 'request' ? HttpRequesterRequestCallback : T extends 'response' ? HttpRequesterResponseCallback : T extends 'iterator' ? HttpRequesterIteratorCallback : never): boolean;
+    GET(opt: HttpRequesterRequestOptions): Promise<any>;
+    POST(opt: HttpRequesterRequestOptions): Promise<any>;
+    POST_ITERATOR(opt: HttpRequesterRequestOptions): Promise<AbortableAsyncIterator<any>>;
+    PUT(opt: HttpRequesterRequestOptions): Promise<any>;
+    PATCH(opt: HttpRequesterRequestOptions): Promise<any>;
+    DELETE(opt: HttpRequesterRequestOptions): Promise<any>;
+    _httpRequest(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', opt: HttpRequesterRequestOptions): Promise<any>;
+    _iteratorRequest(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', opt: HttpRequesterRequestOptions): Promise<AbortableAsyncIterator>;
+}
+export declare class InvalidResponseError extends Error {
+    constructor(message: string);
+}
+export declare class ConnectionClosedUnexpectedlyError extends Error {
+    constructor(message: string);
+}
+export declare class ConnectionError extends Error {
+    constructor(message: string);
+}
+export declare class HttpError extends Error {
+    status: number;
+    statusText: string;
+    constructor(name: string, response: Response, errObj: {
+        textStatus: string;
+    });
+}
+export declare class InformationalError extends HttpError {
+    constructor(response: Response, errObj: {
+        textStatus: string;
+    });
+}
+export declare class SuccessError extends HttpError {
+    constructor(response: Response, errObj: {
+        textStatus: string;
+    });
+}
+export declare class RedirectError extends HttpError {
+    constructor(response: Response, errObj: {
+        textStatus: string;
+    });
+}
+export declare class ClientError extends HttpError {
+    constructor(response: Response, errObj: {
+        textStatus: string;
+    });
+}
+export declare class ServerError extends HttpError {
+    constructor(response: Response, errObj: {
+        textStatus: string;
+    });
+}