harperdb 4.7.3 → 4.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "harperdb",
-	"version": "4.7.3",
+	"version": "4.7.5",
 	"description": "HarperDB is a distributed database, caching service, streaming broker, and application development platform focused on performance and ease of use.",
 	"keywords": [
 		"database",
@@ -85,7 +85,7 @@
 		"json2csv": "5.0.7",
 		"jsonata": "1.8.7",
 		"jsonwebtoken": "9.0.2",
-		"lmdb": "3.4.3",
+		"lmdb": "3.4.4",
 		"lodash": "4.17.21",
 		"mathjs": "11.12.0",
 		"micromatch": "^4.0.8",

package/resources/DatabaseTransaction.d.ts

@@ -6,6 +6,8 @@ export declare const TRANSACTION_STATE: {
     LINGERING: number;
 };
 export declare function replicationConfirmation(callback: any): void;
+declare class StartedTransaction extends Error {
+}
 export declare class DatabaseTransaction implements Transaction {
     #private;
     writes: any[];
@@ -13,10 +15,16 @@ export declare class DatabaseTransaction implements Transaction {
     readTxn: LMDBTransaction;
     readTxnRefCount: number;
     readTxnsUsed: number;
+    timeout: number;
     validated: number;
     timestamp: number;
     next: DatabaseTransaction;
     stale: boolean;
+    startedFrom?: {
+        resourceName: string;
+        method: string;
+    };
+    stackTraces?: StartedTransaction[];
     overloadChecked: boolean;
     open: number;
     getReadTxn(): LMDBTransaction | void;

package/resources/IterableEventQueue.d.ts

@@ -1,32 +1,19 @@
 import { EventEmitter } from 'events';
-export declare class IterableEventQueue extends EventEmitter {
-    resolveNext: Function;
+export declare class IterableEventQueue<Event extends object = any> extends EventEmitter {
+    resolveNext: null | ((args: {
+        value: Event;
+    }) => void);
     queue: any[];
     hasDataListeners: boolean;
     drainCloseListener: boolean;
-    currentDrainResolver: Function;
-    [Symbol.asyncIterator](): EventQueueIterator;
-    push(message: any): void;
-    send(message: any): void;
+    currentDrainResolver: null | ((draining: boolean) => void);
+    [Symbol.asyncIterator](): AsyncIterator<Event>;
+    push(message: Event): void;
+    send(message: Event): void;
     getNextMessage(): any;
     /**
      * Wait for the queue to be drained, resolving to true to continue or false if the queue was closed before draining.
      */
     waitForDrain(): Promise<boolean>;
-    on(eventName: any, listener: any): this;
+    on(eventName: 'data' | string, listener: ((data: Event) => void) | any): this;
 }
-declare class EventQueueIterator {
-    queue: IterableEventQueue;
-    push(message: any): void;
-    next(): Promise<unknown> | {
-        value: any;
-    };
-    return(value: any): {
-        value: any;
-        done: boolean;
-    };
-    throw(error: any): {
-        done: boolean;
-    };
-}
-export {};

package/resources/RequestTarget.d.ts

@@ -1,3 +1,4 @@
+import { UserRoleDatabasePermissions } from '../security/user.types.js';
 import type { Conditions, Id, Select, Sort } from './ResourceInterface.ts';
 export declare class RequestTarget extends URLSearchParams {
     #private;
@@ -16,7 +17,7 @@ export declare class RequestTarget extends URLSearchParams {
     /**	 The number of operator to use*/
     operator?: 'AND' | 'OR';
     /**	 The sort attribute and direction to use */
-    /** @ts-ignore*/
+    /** @ts-expect-error USP has a sort method, we hide it */
     sort?: Sort;
     /**	 The selected attributes to return	 */
     select?: Select;
@@ -36,7 +37,7 @@ export declare class RequestTarget extends URLSearchParams {
     replicatedConfirmation?: number;
     originatingOperation?: string;
     previousResidency?: string[];
-    checkPermission?: Permission | boolean;
+    checkPermission?: UserRoleDatabasePermissions | boolean;
     allowFullScan?: boolean;
     allowConditionsOnDynamicAttributes?: boolean;
     constructor(target?: string);
@@ -47,30 +48,3 @@ export declare class RequestTarget extends URLSearchParams {
     append(name: string, value: string): void;
 }
 export type RequestTargetOrId = RequestTarget | Id;
-interface Permission {
-    read: boolean;
-    update: boolean;
-    delete: boolean;
-    insert: boolean;
-    [database: string]: boolean | {
-        read: boolean;
-        update: boolean;
-        delete: boolean;
-        insert: boolean;
-        tables: {
-            [table: string]: {
-                read: boolean;
-                update: boolean;
-                delete: boolean;
-                insert: boolean;
-                attribute_permissions: {
-                    attribute_name: string;
-                    read: boolean;
-                    update: boolean;
-                    delete: boolean;
-                }[];
-            };
-        };
-    };
-}
-export {};

package/resources/ResourceInterface.d.ts

@@ -1,26 +1,30 @@
-import { DatabaseTransaction } from './DatabaseTransaction.ts';
+import { User } from '../security/user.ts';
 import type { OperationFunctionName } from '../server/serverHelpers/serverUtilities.ts';
+import { DatabaseTransaction } from './DatabaseTransaction.ts';
+import { IterableEventQueue } from './IterableEventQueue.js';
+import type { Entry, RecordObject } from './RecordEncoder.ts';
 import { RequestTarget } from './RequestTarget.ts';
-import type { Entry } from './RecordEncoder.ts';
-export interface ResourceInterface<Key = any, Record = any> {
-    get?(id: Id): Promise<Record>;
-    get?(query: RequestTargetOrId): Promise<AsyncIterable<Record>>;
-    put?(target: RequestTargetOrId, record: any): void;
-    post?(target: RequestTargetOrId, record: any): void;
-    create?(target: RequestTargetOrId, record: any): void;
-    patch?(target: RequestTargetOrId, record: any): void;
-    publish?(target: RequestTargetOrId, record: any): void;
-    update?(updates: any, fullUpdate?: boolean): Promise<UpdatableRecord<Record>>;
+export interface ResourceInterface<Record extends object = any> extends RecordObject, Pick<UpdatableRecord<Record>, 'addTo' | 'subtractFrom'> {
+    new (identifier: Id, source: any): any;
+    allowRead(user: User, target: RequestTarget): boolean | Promise<boolean>;
+    get?(id: Id): Promise<Record & RecordObject>;
+    get?(query: RequestTargetOrId): Promise<AsyncIterable<Record & RecordObject>>;
+    search?(query: RequestTarget): AsyncIterable<Record & RecordObject>;
+    allowCreate(user: User, record: Record & RecordObject, target: RequestTarget): boolean | Promise<boolean>;
+    create?(target: RequestTargetOrId, record: Partial<Record & RecordObject>): void;
+    post?(target: RequestTargetOrId, record: Partial<Record & RecordObject>): void;
+    allowUpdate(user: User, record: Record & RecordObject, target: RequestTarget): boolean | Promise<boolean>;
+    put?(target: RequestTargetOrId, record: Record & RecordObject): void;
+    patch?(target: RequestTargetOrId, record: Partial<Record & RecordObject>): void;
+    update?(updates: Record & RecordObject, fullUpdate: true): ResourceInterface<Record & RecordObject>;
+    update?(updates: Partial<Record & RecordObject>, fullUpdate?: boolean): ResourceInterface<Record & RecordObject> | Promise<ResourceInterface<Record & RecordObject> | UpdatableRecord<Record & RecordObject>>;
+    allowDelete(user: User, target: RequestTarget): boolean | Promise<boolean>;
     delete?(target: RequestTargetOrId): boolean;
-    search?(query: RequestTarget): AsyncIterable<any>;
-    subscribe?(request: SubscriptionRequest): Subscription;
-    allowRead(user: any, target: RequestTarget): boolean | Promise<boolean>;
-    allowUpdate(user: any, record: any, target: RequestTarget): boolean | Promise<boolean>;
-    allowCreate(user: any, record: any, target: RequestTarget): boolean | Promise<boolean>;
-    allowDelete(user: any, target: RequestTarget): boolean | Promise<boolean>;
-}
-export interface User {
-    username: string;
+    invalidate(target: RequestTargetOrId): void | Promise<void>;
+    publish?(target: RequestTargetOrId, record: Record): void;
+    subscribe?(request: SubscriptionRequest): Promise<Subscription<Record & RecordObject>>;
+    doesExist(): boolean;
+    wasLoadedFromSource(): boolean | void;
 }
 export interface Context {
     /**	 The user making the request */
@@ -54,11 +58,11 @@ export interface Context {
     resourceCache?: Map<Id, any>;
     _freezeRecords?: boolean;
 }
-export interface SourceContext<TRequestContext = Context> {
+export interface SourceContext<TRequestContext = Context, Record extends object = any> {
     /** The original request context passed from the caching layer */
     requestContext: TRequestContext;
     /** The existing record, from the existing entry (if any) */
-    replacingRecord?: any;
+    replacingRecord?: Record;
     /** The existing database entry (if any) */
     replacingEntry?: Entry;
     /** The version/timestamp of the existing record */
@@ -66,7 +70,7 @@ export interface SourceContext<TRequestContext = Context> {
     /** Indicates that values from the source data should NOT be stored as a cached value */
     noCacheStore?: boolean;
     /** Reference to the source Resource instance */
-    source?: ResourceInterface;
+    source?: ResourceInterface<Record>;
     /** Shared resource cache from parent context for visibility of modifications */
     resourceCache?: Map<Id, any>;
     /** Database transaction for the context */
@@ -77,25 +81,26 @@ export interface SourceContext<TRequestContext = Context> {
     lastModified?: number;
 }
 export type Operator = 'and' | 'or';
-type Comparator = 'equals' | 'contains' | 'starts_with' | 'ends_with' | 'greater_than' | 'greater_than_equal' | 'less_than' | 'less_than_equal' | 'between';
-export interface DirectCondition {
-    attribute?: string;
-    search_attribute?: string;
+export type Comparator = 'between' | 'contains' | 'ends_with' | 'eq' | 'equals' | 'greater_than' | 'greater_than_equal' | 'less_than' | 'less_than_equal' | 'ne' | 'not_equal' | 'starts_with';
+export type DirectCondition<Record extends object = any> = TypedDirectCondition<Record, keyof Record>;
+interface TypedDirectCondition<Record extends object, Property extends keyof Record> {
+    attribute?: keyof Record | Array<keyof Record> | string | string[];
+    search_attribute?: keyof Record | Array<keyof Record> | string | string[];
     comparator?: Comparator;
     search_type?: Comparator;
-    value?: any;
-    search_value?: any;
+    value?: Record[Property];
+    search_value?: Record[Property];
 }
-interface ConditionGroup {
-    conditions?: Conditions;
+interface ConditionGroup<Record extends object = any> {
+    conditions?: Conditions<Record>;
     operator?: Operator;
 }
-export type Condition = DirectCondition & ConditionGroup;
-export type Conditions = Condition[];
-export interface Sort {
-    attribute: string;
+export type Condition<Record extends object = any> = DirectCondition<Record> & ConditionGroup<Record>;
+export type Conditions<Record extends object = any> = Condition<Record>[];
+export interface Sort<Record extends object = any> {
+    attribute: keyof Record;
     descending?: boolean;
-    next?: Sort;
+    next?: Sort<Record>;
 }
 export interface SubSelect {
     name: string;
@@ -113,12 +118,35 @@ export interface SubscriptionRequest {
     includeDescendants?: boolean;
     supportsTransactions?: boolean;
     rawEvents?: boolean;
-    listener: (data: any) => void;
+    listener: Listener;
 }
 export type Query = RequestTarget;
 export type RequestTargetOrId = RequestTarget | Id;
 export type Id = number | string | (number | string | null)[] | null;
-export type UpdatableRecord<T> = T;
-interface Subscription {
+export type UpdatableRecord<Record extends object = any> = TypedUpdatableRecord<Record, keyof Record>;
+interface TypedUpdatableRecord<Record extends object, Property extends keyof Record> extends RecordObject {
+    set(property: Property, value: Record[Property]): void;
+    getProperty(property: Property): Record[Property];
+    addTo(property: Property, value: Record[Property]): void;
+    subtractFrom(property: Property, value: Record[Property]): void;
+}
+interface Subscription<Event extends object = any> extends IterableEventQueue<Event> {
+    new (listener: Listener<Event>): any;
+    listener: Listener<Event>;
+    subscriptions: Listener<Event>[];
+    startTime?: number;
+    end(): void;
+    toJSON(): {
+        name: 'subscription';
+    };
+}
+type Listener<Payload extends object = any> = (payload: ListenerPayload<Payload>) => void;
+interface ListenerPayload<Payload extends object = any> {
+    id: Id;
+    localTime: number;
+    value: Payload;
+    version: number;
+    type: string;
+    beginTxn: boolean;
 }
 export {};

package/resources/Table.d.ts

@@ -99,11 +99,11 @@ export declare function makeTable(options: any): {
             addTo(property: string, value: number | bigint): void;
             subtractFrom(property: string, value: number | bigint): void;
             "__#private@#record": any;
-            "__#private@#changes": any;
+            "__#private@#changes": Partial<any>;
             getRecord(): any;
             setRecord(record: any): void;
-            getChanges(): any;
-            _setChanges(changes: any): void;
+            getChanges(): Partial<any>;
+            _setChanges(changes: Partial<any>): void;
         };
         addTo(property: any, value: any): void;
         subtractFrom(property: any, value: any): void;
@@ -143,30 +143,19 @@ export declare function makeTable(options: any): {
             toJSON(): {
                 name: string;
             };
-            resolveNext: Function;
+            resolveNext: (args: {
+                value: any;
+            }) => void;
             queue: any[];
             hasDataListeners: boolean;
             drainCloseListener: boolean;
-            currentDrainResolver: Function;
+            currentDrainResolver: null | ((draining: boolean) => void);
             push(message: any): void;
             send(message: any): void;
             getNextMessage(): any;
             waitForDrain(): Promise<boolean>;
-            on(eventName: any, listener: any): /*elided*/ any;
-            [Symbol.asyncIterator](): {
-                queue: import("./IterableEventQueue.js").IterableEventQueue;
-                push(message: any): void;
-                next(): Promise<unknown> | {
-                    value: any;
-                };
-                return(value: any): {
-                    value: any;
-                    done: boolean;
-                };
-                throw(error: any): {
-                    done: boolean;
-                };
-            };
+            on(eventName: "data" | string, listener: ((data: any) => void) | any): /*elided*/ any;
+            [Symbol.asyncIterator](): AsyncIterator<any, any, any>;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
             once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
@@ -308,11 +297,11 @@ export declare function makeTable(options: any): {
             addTo(property: string, value: number | bigint): void;
             subtractFrom(property: string, value: number | bigint): void;
             "__#private@#record": any;
-            "__#private@#changes": any;
+            "__#private@#changes": Partial<any>;
             getRecord(): any;
             setRecord(record: any): void;
-            getChanges(): any;
-            _setChanges(changes: any): void;
+            getChanges(): Partial<any>;
+            _setChanges(changes: Partial<any>): void;
         };
         addTo(property: any, value: any): void;
         subtractFrom(property: any, value: any): void;
@@ -352,30 +341,19 @@ export declare function makeTable(options: any): {
             toJSON(): {
                 name: string;
             };
-            resolveNext: Function;
+            resolveNext: (args: {
+                value: any;
+            }) => void;
             queue: any[];
             hasDataListeners: boolean;
             drainCloseListener: boolean;
-            currentDrainResolver: Function;
+            currentDrainResolver: null | ((draining: boolean) => void);
             push(message: any): void;
             send(message: any): void;
             getNextMessage(): any;
             waitForDrain(): Promise<boolean>;
-            on(eventName: any, listener: any): /*elided*/ any;
-            [Symbol.asyncIterator](): {
-                queue: import("./IterableEventQueue.js").IterableEventQueue;
-                push(message: any): void;
-                next(): Promise<unknown> | {
-                    value: any;
-                };
-                return(value: any): {
-                    value: any;
-                    done: boolean;
-                };
-                throw(error: any): {
-                    done: boolean;
-                };
-            };
+            on(eventName: "data" | string, listener: ((data: any) => void) | any): /*elided*/ any;
+            [Symbol.asyncIterator](): AsyncIterator<any, any, any>;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
             once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
@@ -470,11 +448,11 @@ export declare function makeTable(options: any): {
             addTo(property: string, value: number | bigint): void;
             subtractFrom(property: string, value: number | bigint): void;
             "__#private@#record": any;
-            "__#private@#changes": any;
+            "__#private@#changes": Partial<any>;
             getRecord(): any;
             setRecord(record: any): void;
-            getChanges(): any;
-            _setChanges(changes: any): void;
+            getChanges(): Partial<any>;
+            _setChanges(changes: Partial<any>): void;
         };
         addTo(property: any, value: any): void;
         subtractFrom(property: any, value: any): void;
@@ -514,30 +492,19 @@ export declare function makeTable(options: any): {
             toJSON(): {
                 name: string;
             };
-            resolveNext: Function;
+            resolveNext: (args: {
+                value: any;
+            }) => void;
             queue: any[];
             hasDataListeners: boolean;
             drainCloseListener: boolean;
-            currentDrainResolver: Function;
+            currentDrainResolver: null | ((draining: boolean) => void);
             push(message: any): void;
             send(message: any): void;
             getNextMessage(): any;
             waitForDrain(): Promise<boolean>;
-            on(eventName: any, listener: any): /*elided*/ any;
-            [Symbol.asyncIterator](): {
-                queue: import("./IterableEventQueue.js").IterableEventQueue;
-                push(message: any): void;
-                next(): Promise<unknown> | {
-                    value: any;
-                };
-                return(value: any): {
-                    value: any;
-                    done: boolean;
-                };
-                throw(error: any): {
-                    done: boolean;
-                };
-            };
+            on(eventName: "data" | string, listener: ((data: any) => void) | any): /*elided*/ any;
+            [Symbol.asyncIterator](): AsyncIterator<any, any, any>;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
             once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;

package/resources/blob.d.ts

@@ -11,7 +11,6 @@
  *   - Note that for compressed data, the size is the uncompressed size, and the compressed size in the file
  */
 import type { LMDBStore } from 'lmdb';
-import * as buffer from 'node:buffer';
 type StorageInfo = {
     storageIndex: number;
     fileId: string;
@@ -40,7 +39,7 @@ export declare const Blob: {
         arrayBuffer(): Promise<ArrayBufferLike>;
         get size(): number;
         slice(): /*elided*/ any;
-        bytes(): Promise<buffer.Buffer>;
+        bytes(): Promise<Buffer>;
         get type(): string;
     };
 };
@@ -54,7 +53,7 @@ declare namespace InstanceOfBlobWithNoConstructor {
         arrayBuffer(): Promise<ArrayBufferLike>;
         get size(): number;
         slice(): /*elided*/ any;
-        bytes(): Promise<buffer.Buffer>;
+        bytes(): Promise<Buffer>;
         get type(): string;
     };
 }
@@ -156,5 +155,5 @@ export declare function startPreCommitBlobsForRecord(record: any, store: LMDBSto
  * from the database, and if not, deletes them
  * @param database
  */
-export declare function cleanupOrphans(database: any): Promise<number>;
+export declare function cleanupOrphans(database: any, databaseName?: string): Promise<number>;
 export {};

package/resources/tracked.d.ts

@@ -10,13 +10,13 @@
  * @param typeDef Type definition for determining property
  */
 export declare function assignTrackedAccessors(Target: any, typeDef: any, useFullPropertyProxy?: boolean): void;
-export declare class GenericTrackedObject {
+export declare class GenericTrackedObject<T extends object = any> {
     #private;
-    constructor(sourceObject: any);
-    getRecord(): any;
-    setRecord(record: any): void;
-    getChanges(): any;
-    _setChanges(changes: any): void;
+    constructor(sourceObject?: GenericTrackedObject<T> | T);
+    getRecord(): T;
+    setRecord(record: T): void;
+    getChanges(): Partial<T>;
+    _setChanges(changes: Partial<T>): void;
 }
 /**
  * Collapse the changed and transitive and source/record data into single object that

package/security/user.d.ts

@@ -0,0 +1,81 @@
+declare const USERNAME_REQUIRED = "username is required";
+declare const ALTERUSER_NOTHING_TO_UPDATE = "nothing to update, must supply active, role or password to update";
+declare const EMPTY_PASSWORD = "password cannot be an empty string";
+declare const EMPTY_ROLE = "If role is specified, it cannot be empty.";
+declare const ACTIVE_BOOLEAN = "active must be true or false";
+export { addUser, alterUser, dropUser, getSuperUser, userInfo, listUsers, listUsersExternal, setUsersWithRolesCache, findAndValidateUser, getClusterUser, getUsersWithRolesCache, USERNAME_REQUIRED, ALTERUSER_NOTHING_TO_UPDATE, EMPTY_PASSWORD, EMPTY_ROLE, ACTIVE_BOOLEAN, };
+export interface User {
+    active?: boolean;
+    username: string;
+    role?: UserRole;
+    __updatedtime__?: number;
+    __createdtime__?: number;
+    [other: string]: unknown;
+}
+export interface UserRole {
+    permission: UserRoleNamedPermissions & UserRoleDatabasePermissions;
+    role: string;
+    id: string;
+    __updatedtime__: number;
+    __createdtime__: number;
+}
+export interface UserRoleNamedPermissions extends Partial<CRUDPermissions> {
+    super_user?: boolean;
+    cluster_user?: boolean;
+    structure_user?: boolean;
+}
+export interface UserRoleDatabasePermissions {
+    [databaseName: string]: UserRoleSchemaRecord;
+}
+export interface UserRoleSchemaRecord extends Partial<CRUDPermissions> {
+    tables: Record<string, UserRolePermissionTable | UserLegacyRolePermissionTable>;
+}
+export interface UserRolePermissionTable extends CRUDPermissions {
+    attribute_permissions: UserRoleAttributePermissionTable[];
+}
+export interface UserRoleAttributePermissionTable extends Omit<CRUDPermissions, 'delete'> {
+    attribute_name: string;
+}
+export interface UserLegacyRolePermissionTable extends CRUDPermissions {
+    attribute_restrictions: UserLegacyRoleAttributePermissionTable[];
+}
+export interface UserLegacyRoleAttributePermissionTable extends CRUDPermissions {
+    attribute_name: string;
+}
+export interface CRUDPermissions {
+    read: boolean;
+    insert: boolean;
+    update: boolean;
+    delete: boolean;
+}
+declare function addUser(user: User | any): Promise<string>;
+declare function alterUser(jsonMessage: any): Promise<any>;
+declare function dropUser(user: User | any): Promise<string>;
+declare function userInfo(body: any): Promise<string | User>;
+/**
+ * This function should be called by chooseOperation as it scrubs sensitive information before returning
+ * the results of list users.
+ */
+declare function listUsersExternal(): Promise<User[]>;
+/**
+ * Queries system table for user records, adds role-based perms, scrubs list based on licensed role allowance and returns
+ * data in a Map with the username as the key for the entry
+ */
+declare function listUsers(): Promise<Map<string, User>>;
+declare function setUsersWithRolesCache(cache?: any): Promise<void>;
+declare function getUsersWithRolesCache(): Promise<any>;
+/**
+ * iterates global.hdb_users to find and validate the username & optionally the password as well as if they are active.
+ * @param {string} username
+ * @param {string} pw
+ * @param {boolean} validatePassword
+ */
+declare function findAndValidateUser(username: string, pw?: string | null, validatePassword?: boolean): Promise<User>;
+declare function getSuperUser(): Promise<User | undefined>;
+/**
+ * Gets the cluster user provided in harperdb-config.yaml from the map of all user.
+ * Nats requires plain test passwords, this is why we pass decrypt_hash.
+ * The Nats routes require the decrypt_hash to be uri encoded.
+ * @returns {Promise<Object>}
+ */
+declare function getClusterUser(): Promise<User | undefined>;