@nymphjs/client 1.0.0-beta.13 → 1.0.0-beta.130

package/dist/Nymph.types.d.ts

@@ -0,0 +1,227 @@
+import { EntityConstructor, EntityInterface } from './Entity.types.js';
+export type NymphOptions = {
+    /**
+     * The URL of your Nymph REST server.
+     */
+    restUrl: string;
+    /**
+     * The URL of your Nymph PubSub server.
+     */
+    pubsubUrl?: string;
+    /**
+     * A fetch implementation.
+     */
+    fetch?: WindowOrWorkerGlobalScope['fetch'];
+    /**
+     * A WebSocket implementation.
+     */
+    WebSocket?: typeof WebSocket;
+    /**
+     * Return `null` or empty array instead of error when entity/ies not found.
+     */
+    returnNullOnNotFound?: boolean;
+    /**
+     * 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.
+     *
+     * 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;
+    /**
+     * Whether to renew tokens when a request is made.
+     *
+     * If you turn this off, the client will request that the server not renew an
+     * authentication token, even if it is within the renewal time of the
+     * expiration date.
+     *
+     * This defaults to true.
+     */
+    renewTokens?: boolean;
+};
+export type EventType = 'request' | 'response';
+export type RequestCallback = (url: string, options: RequestInit) => void;
+export type ResponseCallback = (response: Response, text: string) => void;
+export type Options<T extends EntityConstructor = EntityConstructor> = {
+    /**
+     * The Entity class to query.
+     */
+    class: T;
+    /**
+     * The limit of entities to be returned. Not needed when using `getEntity`, as
+     * it always returns only one.
+     */
+    limit?: number;
+    /**
+     * The offset from the first matching entity, in order, to start retrieving.
+     */
+    offset?: number;
+    /**
+     * If true, entities will be retrieved from newest to oldest/largest to
+     * smallest (with regard to `sort`).
+     */
+    reverse?: boolean;
+    /**
+     * How to sort the entities. Should be "cdate", "mdate", the name of a
+     * property, or null.
+     */
+    sort?: 'cdate' | 'mdate' | string | null;
+    /**
+     * What to return, the entities with their data, just the GUIDs, or just a
+     * count.
+     */
+    return?: 'entity' | 'guid' | 'count';
+    /**
+     * If true, Nymph will skip the cache and retrieve the entity from the DB.
+     */
+    skipCache?: boolean;
+    /**
+     * The level(s) of access control requested.
+     *
+     * Limiting the access control can significantly improve the performance of
+     * the query.
+     */
+    acRequest?: TilmeldAccessRequest;
+};
+export type Clause<C> = C | Exclude<C, undefined>[];
+export type OrWithTime<T> = T | [string, null, string];
+type PrimitiveSelector = {
+    guid?: string;
+    '!guid'?: PrimitiveSelector['guid'];
+    tag?: string;
+    '!tag'?: PrimitiveSelector['tag'];
+    defined?: string;
+    '!defined'?: PrimitiveSelector['defined'];
+    truthy?: string;
+    '!truthy'?: PrimitiveSelector['truthy'];
+    equal?: [string, any];
+    '!equal'?: PrimitiveSelector['equal'];
+    contain?: [string, any];
+    '!contain'?: PrimitiveSelector['contain'];
+    search?: [string, string];
+    '!search'?: PrimitiveSelector['search'];
+    match?: [string, string];
+    '!match'?: PrimitiveSelector['match'];
+    imatch?: [string, string];
+    '!imatch'?: PrimitiveSelector['imatch'];
+    like?: [string, string];
+    '!like'?: PrimitiveSelector['like'];
+    ilike?: [string, string];
+    '!ilike'?: PrimitiveSelector['ilike'];
+    gt?: [string, number];
+    '!gt'?: PrimitiveSelector['gt'];
+    gte?: [string, number];
+    '!gte'?: PrimitiveSelector['gte'];
+    lt?: [string, number];
+    '!lt'?: PrimitiveSelector['lt'];
+    lte?: [string, number];
+    '!lte'?: PrimitiveSelector['lte'];
+    ref?: [string, EntityInterface | string];
+    '!ref'?: PrimitiveSelector['ref'];
+    qref?: [string, [Options, ...PrimitiveSelector[]]];
+    '!qref'?: PrimitiveSelector['qref'];
+    selector?: PrimitiveSelector;
+    '!selector'?: PrimitiveSelector['selector'];
+};
+export type Selector = {
+    type: '&' | '|' | '!&' | '!|';
+    guid?: Clause<PrimitiveSelector['guid']>;
+    '!guid'?: Clause<PrimitiveSelector['guid']>;
+    tag?: Clause<PrimitiveSelector['tag']>;
+    '!tag'?: Clause<PrimitiveSelector['tag']>;
+    defined?: Clause<PrimitiveSelector['defined']>;
+    '!defined'?: Clause<PrimitiveSelector['defined']>;
+    truthy?: Clause<PrimitiveSelector['truthy']>;
+    '!truthy'?: Clause<PrimitiveSelector['truthy']>;
+    equal?: Clause<OrWithTime<PrimitiveSelector['equal']>>;
+    '!equal'?: Clause<OrWithTime<PrimitiveSelector['equal']>>;
+    contain?: Clause<OrWithTime<PrimitiveSelector['contain']>>;
+    '!contain'?: Clause<OrWithTime<PrimitiveSelector['contain']>>;
+    search?: Clause<PrimitiveSelector['search']>;
+    '!search'?: Clause<PrimitiveSelector['search']>;
+    match?: Clause<PrimitiveSelector['match']>;
+    '!match'?: Clause<PrimitiveSelector['match']>;
+    imatch?: Clause<PrimitiveSelector['imatch']>;
+    '!imatch'?: Clause<PrimitiveSelector['imatch']>;
+    like?: Clause<PrimitiveSelector['like']>;
+    '!like'?: Clause<PrimitiveSelector['like']>;
+    ilike?: Clause<PrimitiveSelector['ilike']>;
+    '!ilike'?: Clause<PrimitiveSelector['ilike']>;
+    gt?: Clause<OrWithTime<PrimitiveSelector['gt']>>;
+    '!gt'?: Clause<OrWithTime<PrimitiveSelector['gt']>>;
+    gte?: Clause<OrWithTime<PrimitiveSelector['gte']>>;
+    '!gte'?: Clause<OrWithTime<PrimitiveSelector['gte']>>;
+    lt?: Clause<OrWithTime<PrimitiveSelector['lt']>>;
+    '!lt'?: Clause<OrWithTime<PrimitiveSelector['lt']>>;
+    lte?: Clause<OrWithTime<PrimitiveSelector['lte']>>;
+    '!lte'?: Clause<OrWithTime<PrimitiveSelector['lte']>>;
+    ref?: Clause<PrimitiveSelector['ref']>;
+    '!ref'?: Clause<PrimitiveSelector['ref']>;
+    qref?: Clause<[string, [Options, ...Selector[]]]>;
+    '!qref'?: Selector['qref'];
+    selector?: Clause<Selector>;
+    '!selector'?: Selector['selector'];
+};
+export declare enum TilmeldAccessRequest {
+    /**
+     * The default level, any possible entity readable by the user.
+     *
+     * This is the same as or-ing together all of the levels listed below.
+     */
+    ALL_LEVELS = 0,
+    /**
+     * Owned by and accessible to the user.
+     *
+     * This is always enabled, so not including it has no effect. It's here to
+     * allow the selection of _only_ user owned entities.
+     */
+    USER_OWNED = 1,
+    /**
+     * Owned by and accessible to the user's primary group.
+     */
+    PRIMARY_GROUP_OWNED = 2,
+    /**
+     * Owned by and accessible to one of the user's secondary groups.
+     */
+    SECONDARY_GROUP_OWNED = 4,
+    /**
+     * The user is listed in an access control list.
+     */
+    USER_ACCESSIBLE = 8,
+    /**
+     * The user's primary group is listed in an access control list.
+     */
+    PRIMARY_GROUP_ACCESSIBLE = 16,
+    /**
+     * One of the user's secondary groups is listed in an access control list.
+     */
+    SECONDARY_GROUP_ACCESSIBLE = 32,
+    /**
+     * The entity is accessible to any user.
+     */
+    OTHER_ACCESSIBLE = 64,
+    /**
+     * The entity is not owned by anyone.
+     */
+    UNOWNED = 128
+}
+export {};

package/dist/Nymph.types.js

@@ -0,0 +1,45 @@
+export var TilmeldAccessRequest;
+(function (TilmeldAccessRequest) {
+    /**
+     * The default level, any possible entity readable by the user.
+     *
+     * This is the same as or-ing together all of the levels listed below.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["ALL_LEVELS"] = 0] = "ALL_LEVELS";
+    /**
+     * Owned by and accessible to the user.
+     *
+     * This is always enabled, so not including it has no effect. It's here to
+     * allow the selection of _only_ user owned entities.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["USER_OWNED"] = 1] = "USER_OWNED";
+    /**
+     * Owned by and accessible to the user's primary group.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["PRIMARY_GROUP_OWNED"] = 2] = "PRIMARY_GROUP_OWNED";
+    /**
+     * Owned by and accessible to one of the user's secondary groups.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["SECONDARY_GROUP_OWNED"] = 4] = "SECONDARY_GROUP_OWNED";
+    /**
+     * The user is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["USER_ACCESSIBLE"] = 8] = "USER_ACCESSIBLE";
+    /**
+     * The user's primary group is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["PRIMARY_GROUP_ACCESSIBLE"] = 16] = "PRIMARY_GROUP_ACCESSIBLE";
+    /**
+     * One of the user's secondary groups is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["SECONDARY_GROUP_ACCESSIBLE"] = 32] = "SECONDARY_GROUP_ACCESSIBLE";
+    /**
+     * The entity is accessible to any user.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["OTHER_ACCESSIBLE"] = 64] = "OTHER_ACCESSIBLE";
+    /**
+     * The entity is not owned by anyone.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["UNOWNED"] = 128] = "UNOWNED";
+})(TilmeldAccessRequest || (TilmeldAccessRequest = {}));
+//# sourceMappingURL=Nymph.types.js.map

package/dist/Nymph.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Nymph.types.js","sourceRoot":"","sources":["../src/Nymph.types.ts"],"names":[],"mappings":"AAoOA,MAAM,CAAN,IAAY,oBA0CX;AA1CD,WAAY,oBAAoB;IAC9B;;;;OAIG;IACH,2EAAc,CAAA;IACd;;;;;OAKG;IACH,2EAAc,CAAA;IACd;;OAEG;IACH,6FAAuB,CAAA;IACvB;;OAEG;IACH,iGAAyB,CAAA;IACzB;;OAEG;IACH,qFAAmB,CAAA;IACnB;;OAEG;IACH,wGAA6B,CAAA;IAC7B;;OAEG;IACH,4GAA+B,CAAA;IAC/B;;OAEG;IACH,wFAAqB,CAAA;IACrB;;OAEG;IACH,uEAAa,CAAA;AACf,CAAC,EA1CW,oBAAoB,KAApB,oBAAoB,QA0C/B"}

package/{lib → dist}/PubSub.d.ts

@@ -1,9 +1,12 @@
-import Nymph from './Nymph';
-import { NymphOptions, Options, Selector } from './Nymph.types';
-import { EntityConstructor, EntityInterface } from './Entity.types';
-import { PubSubCallbacks, PubSubConnectCallback, PubSubCountCallback, PubSubDisconnectCallback, PubSubEventType, PubSubRejectCallback, PubSubResolveCallback, PubSubSubscribable, PubSubUpdate } from './PubSub.types';
+import Nymph from './Nymph.js';
+import type { NymphOptions, Options, Selector } from './Nymph.types.js';
+import type { EntityInstanceType } from './Entity.js';
+import type { EntityConstructor, EntityInterface } from './Entity.types.js';
+import type { PubSubCallbacks, PubSubConnectCallback, PubSubCountCallback, PubSubDisconnectCallback, PubSubEventType, PubSubRejectCallback, PubSubResolveCallback, PubSubErrorCallback, PubSubSubscribable, PubSubUpdate } from './PubSub.types.js';
 export default class PubSub {
     private nymph;
+    private authToken;
+    private switchToken;
     private connection;
     private waitForConnectionTimeout;
     private pubsubUrl;
@@ -11,16 +14,17 @@ export default class PubSub {
     private subscriptions;
     private connectCallbacks;
     private disconnectCallbacks;
+    private errorCallbacks;
     private noConsole;
     constructor(nymphOptions: NymphOptions, nymph: Nymph);
     subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T> & {
         return: 'guid';
     }, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<string[]>>;
-    subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']>[]>>;
+    subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T>[]>>;
     subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T> & {
         return: 'guid';
     }, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<string | null>>;
-    subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']> | null>>;
+    subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T> | null>>;
     subscribeUID(name: string): (resolve?: PubSubResolveCallback<number> | undefined, reject?: PubSubRejectCallback | undefined, count?: PubSubCountCallback | undefined) => {
         unsubscribe: () => void;
     };
@@ -34,6 +38,8 @@ export default class PubSub {
     private _onclose;
     private _send;
     isConnectionOpen(): boolean;
+    isConnectionConnecting(): boolean;
+    isConnection(): boolean;
     private _subscribeQuery;
     private _subscribeUID;
     private _sendQuery;
@@ -44,10 +50,10 @@ export default class PubSub {
     private _unsubscribeUID;
     private _sendUnQuery;
     private _sendUnUID;
-    updateArray(oldArr: EntityInterface[], update: PubSubUpdate<EntityInterface[]>): void;
-    on<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : never): () => boolean;
-    off<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : never): boolean;
-    setToken(token: string | null): void;
+    updateArray(current: EntityInterface[], update: PubSubUpdate<EntityInterface[]>): void;
+    on<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : T extends 'error' ? PubSubErrorCallback : never): () => boolean;
+    off<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : T extends 'error' ? PubSubErrorCallback : never): boolean;
+    authenticate(authToken: string | null, switchToken?: string | null): void;
 }
 export declare class PubSubSubscription<T> {
     query: string;