@litbase/react 4.0.7 → 4.0.11

package/binary-id/src/base64.d.ts

@@ -0,0 +1,18 @@
+/**
+ * use this to make a Base64 encoded string URL friendly,
+ * i.e. '+' and '/' are replaced with '-' and '_' also any trailing '='
+ * characters are removed
+ *
+ * @param {String} str the encoded string
+ * @returns {String} the URL friendly encoded String
+ */
+export declare function toUrlSafeBase64(str: string): string;
+/**
+ * Use this to recreate a Base64 encoded string that was made URL friendly
+ * using Base64EncodeurlFriendly.
+ * '-' and '_' are replaced with '+' and '/' and also it is padded with '+'
+ *
+ * @param {String} str the encoded string
+ * @returns {String} the URL friendly encoded String
+ */
+export declare function fromUrlSafeBase64(str: string): string;

package/binary-id/src/binary-id-generator.d.ts

@@ -0,0 +1,20 @@
+import { BinaryId } from "./binary-id.js";
+export declare class BinaryIdGenerator {
+    counter: number;
+    constructor(counter?: number);
+    create(): BinaryId;
+    createNested(id: BinaryId): BinaryId;
+    protected getCurrentTime(): number;
+    protected fillRandomValues(buffer: Uint8Array): void;
+}
+export declare class TestBinaryIdGenerator extends BinaryIdGenerator {
+    constructor();
+    peekNext(): BinaryId;
+    createWithCounter(value: number): BinaryId;
+    protected getCurrentTime(): number;
+    protected fillRandomValues(buffer: Uint8Array): void;
+}
+export declare let defaultBinaryIdGenerator: BinaryIdGenerator;
+export declare function replaceDefaultBinaryIdGenerator(newValue: BinaryIdGenerator): void;
+export declare function createBinaryId(): BinaryId;
+export declare function createNestedBinaryId(nested: BinaryId): BinaryId;

package/binary-id/src/binary-id.d.ts

@@ -0,0 +1,28 @@
+export declare const binaryIdByteLength = 12;
+export declare const nestedBinaryIdByteLength: number;
+export declare const binaryIdStringLength: number;
+export declare const nestedBinaryIdStringLength: number;
+export declare class BinaryId {
+    get length(): number;
+    get isNested(): boolean;
+    get isEmpty(): boolean;
+    get isInvalid(): boolean;
+    readonly value: string;
+    static equals(a: BinaryId | null | undefined, b: BinaryId | null | undefined): boolean;
+    static fromBase64String(value: string): BinaryId;
+    static fromUrlSafeString(value: string): BinaryId;
+    constructor(value: string | ArrayBufferView | BinaryId);
+    equals(other: BinaryId): boolean;
+    compare(other: BinaryId): number;
+    getNested(): BinaryId;
+    getDate(): Date;
+    toBinary(): Uint8Array;
+    toUrlSafeString(): string;
+    toBase64String(): string;
+    toString(): string;
+    toJSON(): string;
+    valueOf(): string;
+}
+export declare const EMPTY_ID: BinaryId;
+export declare const EMPTY_NESTED_ID: BinaryId;
+export declare const INVALID_ID: BinaryId;

package/binary-id/src/binary-string.d.ts

@@ -0,0 +1,2 @@
+export declare function toBinaryString(view: ArrayBufferView, sortable?: boolean): string;
+export declare function fromBinaryString(value: string): Uint8Array;

package/binary-id/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./binary-id.js";
+export * from "./binary-id-generator.js";
+export * from "./base64.js";
+export * from "./binary-string.js";

package/client/src/config.d.ts

@@ -0,0 +1,12 @@
+import { ProjectionObject, RpcMessageLoggerOptions } from "@litbase/core";
+import { UploadFileOptions } from "./litbase-client.js";
+export declare const config: ClientConfigInterface;
+export interface ClientConfigInterface {
+    url: string;
+    pingEnabled: boolean;
+    currentUserFields: ProjectionObject;
+    debug: boolean | RpcMessageLoggerOptions;
+    usePreSignedUploads: boolean;
+    continueWithSessionTimeoutMs: number;
+    defaultUploadOptions: UploadFileOptions;
+}

package/client/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./litbase-client.js";
+export * from "./config.js";
+export * from "./upload-file-to-url.js";

package/client/src/litbase-client.d.ts

@@ -0,0 +1,62 @@
+import { AddUserWithEmailOptions, ChangePasswordOptions, GetUploadUrlOptions, LitQL, LoginResult, LoginWithOAuthOptions, OAuthProvider, UserInterface, WaitForEmailConfirmationOptions } from "@litbase/core";
+import { BehaviorSubject, Observable } from "rxjs";
+import { UploadStatus } from "./upload-file-to-url.js";
+import { ClientConfigInterface } from "./config.js";
+import { WebSocketRpcClient, RpcDefinition } from "@litbase/rxpc";
+export interface UploadFileStatus extends UploadStatus {
+    contentUrl?: string;
+}
+export interface UploadFileOptions extends Omit<GetUploadUrlOptions, "filename" | "size" | "contentType"> {
+}
+export declare class LitbaseClient {
+    readonly litql: LitQL;
+    private readonly config;
+    client: WebSocketRpcClient | null;
+    currentUser: UserInterface;
+    readonly currentUser$: BehaviorSubject<UserInterface>;
+    private readonly client$;
+    constructor(litql?: LitQL, config?: ClientConfigInterface);
+    connect(): Promise<void>;
+    private tryConnect;
+    callObservable<TArgs extends any[], TResult>(definition: RpcDefinition<TArgs, TResult>, ...args: TArgs): Observable<TResult>;
+    call<TArgs extends any[], TResult>(definition: RpcDefinition<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
+    callHttp<TArgs extends any[], TResult>(definition: RpcDefinition<TArgs, TResult>, ...args: TArgs): Promise<unknown>;
+    changeUserName(username: string): Promise<import("@litbase/core").DocumentInterface | null>;
+    confirmEmailLogin(options: {
+        emailToken: string;
+        loginHere: boolean;
+    }): Promise<LoginResult | undefined>;
+    loginWithEmail(options: {
+        email: string;
+        captchaResponse?: string;
+    }): Promise<void>;
+    loginWithEmailAndPassword(options: {
+        email: string;
+        password: string;
+    }): Promise<LoginResult>;
+    registerWithEmailAndPassword(options: {
+        email: string;
+        password: string;
+        name: string;
+    }): Promise<LoginResult>;
+    addUserWithEmail(options: AddUserWithEmailOptions): Promise<UserInterface>;
+    addUserWithEmailAndPassword(options: {
+        email: string;
+        password: string;
+        name: string;
+    }): Promise<UserInterface>;
+    getCurrentUser(): Promise<UserInterface>;
+    isSameBrowser(): Promise<boolean>;
+    waitForEmailConfirmation(options: WaitForEmailConfirmationOptions): Promise<LoginResult>;
+    loginWithOAuth(provider: OAuthProvider, options: LoginWithOAuthOptions): Promise<LoginResult>;
+    logout(): Promise<void>;
+    changePassword(options: ChangePasswordOptions): Promise<void>;
+    uploadFile(file: File, options?: UploadFileOptions): Observable<UploadFileStatus>;
+    getSessionVariable<T, TDefault = undefined>(key: string, defaultValue?: TDefault): Promise<T | TDefault>;
+    private waitForConnection;
+    private ensureSession;
+    private processLoginResult;
+    private getAbsoluteUrl;
+    private getUrl;
+}
+export declare const client: any;

package/client/src/remote-collection.d.ts

@@ -0,0 +1,16 @@
+import { BulkWriteOperation, DatabaseCollectionInterface, FindOptions, Projection } from "@litbase/core";
+import { Observable } from "rxjs";
+import { LitbaseClient } from "./litbase-client.js";
+export declare class RemoteCollection implements DatabaseCollectionInterface {
+    readonly name: string;
+    readonly client: LitbaseClient;
+    constructor(name: string, client: LitbaseClient);
+    bulkWrite(operations: BulkWriteOperation<object>[], ordered?: boolean): Promise<void>;
+    find(query?: object, projection?: Projection, options?: FindOptions): Observable<object[]>;
+    findSnapshot(query?: object, projection?: Projection, options?: FindOptions): Promise<object[]>;
+    insert(docs: object[]): Promise<void>;
+    remove(query: object, multi?: boolean): Promise<void>;
+    update(query: object, update: object, multi?: boolean): Promise<void>;
+    upsert(query: object, update: object, multi?: boolean): Promise<void>;
+    private queryRemote;
+}

package/client/src/upload-file-to-url.d.ts

@@ -0,0 +1,26 @@
+import { AjaxResponse } from "rxjs/ajax";
+import { Observable } from "rxjs";
+export declare enum UploadStatusStatus {
+    Done = "done",
+    Working = "working",
+    Errored = "errored"
+}
+export interface UploadStatus {
+    status: UploadStatusStatus;
+    file: File;
+    progress: number;
+    error?: Error;
+    response?: AjaxResponse<UploadResponseBody>;
+}
+interface UploadResponseBody {
+    status: string;
+    url: string;
+}
+export interface UploadFileToUrlOptions {
+    extraFields?: Record<string, string>;
+    extraHeaders?: Record<string, string>;
+    useFormData?: boolean;
+    method?: string;
+}
+export declare function uploadFileToUrl(file: File, url: string, { extraHeaders, extraFields, useFormData, method }?: UploadFileToUrlOptions): Observable<UploadStatus>;
+export {};

package/client-react/src/hooks/use-current-user.d.ts

@@ -0,0 +1,2 @@
+import { UserInterface } from "@litbase/core";
+export declare function useCurrentUser<TUser extends UserInterface = UserInterface>(): TUser;

package/client-react/src/hooks/use-query.d.ts

@@ -0,0 +1,7 @@
+import { DocumentInterface, MultiObservableQueryObject, MultiPromiseQueryObject, QueryOptions, QueryTypeBody, SingleObservableQueryObject, SinglePromiseQueryObject } from "@litbase/core";
+export declare function useQueryTypeOne<TDoc extends DocumentInterface>(typeName: string, query: QueryTypeBody | null, options?: QueryOptions): [TDoc | null, boolean, Error | null, boolean];
+export declare function useQueryType<TDoc extends DocumentInterface>(typeName: string, query: QueryTypeBody | null, options?: QueryOptions): [TDoc[], boolean, Error | null, boolean];
+export declare function useQuery<T extends DocumentInterface>(name: string, query: SinglePromiseQueryObject | null): [T | null, boolean, Error | null, boolean];
+export declare function useQuery<T extends DocumentInterface>(name: string, query: MultiPromiseQueryObject | null): [T[], boolean, Error | null, boolean];
+export declare function useQuery<T extends DocumentInterface>(name: string, query: SingleObservableQueryObject | null): [T | null, boolean, Error | null, boolean];
+export declare function useQuery<T extends DocumentInterface>(name: string, query: MultiObservableQueryObject | null): [T[], boolean, Error | null, boolean];

package/client-react/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hooks/use-query.js";
+export { useCurrentUser } from "./hooks/use-current-user.js";

package/core/src/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./user-interface.js";
+export * from "./session-interface.js";

package/core/src/auth/session-interface.d.ts

@@ -0,0 +1,33 @@
+import { BinaryId } from "@litbase/binary-id";
+import { DocumentInterface } from "../litql/index.js";
+export type SessionId = string;
+export interface SessionInterface extends DocumentInterface {
+    sessionId: SessionId;
+    createdAt: Date;
+    rotateAt: Date;
+    expiresAt: Date;
+    lastSeen: Date;
+    values: SessionValues;
+}
+export declare const userIdSessionKey: "userId";
+export declare const sameBrowserTokenSessionKey: "sameBrowserToken";
+export type SessionValues = {
+    [userIdSessionKey]?: {
+        value: BinaryId;
+        visibility: ClientVisibility.read;
+    };
+    [sameBrowserTokenSessionKey]?: {
+        value: BinaryId;
+        visibility: ClientVisibility.read;
+    };
+    [key: string]: SessionValue | undefined;
+};
+export interface SessionValue {
+    value: any;
+    visibility: ClientVisibility;
+}
+export declare enum ClientVisibility {
+    readWrite = "readWrite",
+    read = "read",
+    hidden = "hidden"
+}

package/core/src/auth/user-interface.d.ts

@@ -0,0 +1,27 @@
+import { DocumentInterface } from "../litql/index.js";
+import { OAuthProvider } from "../rpc-definitions/auth-definitions.js";
+export interface UserInterface extends DocumentInterface {
+    name: string;
+    providers: {
+        [key in OAuthProvider]?: {
+            id: string;
+        };
+    } & {
+        email?: {
+            id: string;
+            hashedPassword?: string;
+        };
+    };
+}
+/**
+ * @deprecated Use {@link UserInterface} instead
+ */
+export type BaseUserInterface = UserInterface;
+/**
+ * @deprecated Use {@link UserInterface} instead
+ */
+export type RegisteredUser = UserInterface;
+export declare const emptyUser: UserInterface;
+export declare const guestUser: UserInterface;
+export declare function isEmptyUser(user: UserInterface): boolean;
+export declare function isUserGuest(user: UserInterface): boolean;

package/core/src/errors/auth-error.d.ts

@@ -0,0 +1,3 @@
+export declare class AuthError extends Error {
+    constructor(...params: any[]);
+}

package/core/src/errors/index.d.ts

@@ -0,0 +1 @@
+export { AuthError } from "./auth-error.js";

package/core/src/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./errors/index.js";
+export * from "@litbase/binary-id";
+export * from "@litbase/rxpc";
+export * from "./auth/index.js";
+export * from "./litql/index.js";
+export * from "@litbase/event-emitter";
+export * from "./utils/exhaust-map-with-trailing.js";
+export * from "@litbase/utils";
+export * from "./utils/get-value-of.js";
+export * from "./utils/iterable-utils.js";
+export * from "./utils/create-change-observable.js";
+export * from "./utils/simple-object-iterator.js";
+export * from "./utils/deep-assign.js";
+export * from "./utils/deep-transform.js";
+export * from "./utils/get-in.js";
+export * from "./utils/set.js";
+export * from "./utils/is-plain-object.js";
+export * from "./utils/is-email.js";
+export * from "./logger/index.js";
+export * from "./rpc-definitions/index.js";
+export * from "./rpc-client-definitions/index.js";
+export * from "./rpc-message-logger.js";

package/core/src/litql/bulk-write-operation.d.ts

@@ -0,0 +1,31 @@
+import { DocumentInterface } from "./database-interface.js";
+interface InsertOneOperation<TDoc> {
+    insertOne: {
+        document: TDoc;
+    };
+}
+interface UpdateOneOperation {
+    updateOne: {
+        filter: object;
+        update: object;
+        upsert?: boolean;
+    };
+}
+interface UpdateManyOperation {
+    updateMany: {
+        filter: object;
+        update: object;
+    };
+}
+interface DeleteOneOperation {
+    deleteOne: {
+        filter: object;
+    };
+}
+interface DeleteManyOperation {
+    deleteMany: {
+        filter: object;
+    };
+}
+export type BulkWriteOperation<TDoc = DocumentInterface> = InsertOneOperation<TDoc> | UpdateOneOperation | UpdateManyOperation | DeleteOneOperation | DeleteManyOperation;
+export {};

package/core/src/litql/database-interface.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from "rxjs";
+import { BulkWriteOperation } from "./bulk-write-operation.js";
+import { BinaryId } from "@litbase/binary-id";
+export type SortOptions = {
+    [key: string]: 1 | -1;
+};
+type IncludeProjection<T> = {
+    [Prop in keyof T]?: 1 | IncludeProjection<T[Prop]>;
+};
+type ExcludeProjection<T> = {
+    [Prop in keyof T]?: 0 | ExcludeProjection<T[Prop]>;
+};
+export type Projection<T = {}> = IncludeProjection<T> | ExcludeProjection<T>;
+export interface FindOptions {
+    sort?: SortOptions | null;
+    limit?: number | null;
+    skip?: number | null;
+    allFields?: boolean;
+}
+export interface DatabaseInterface {
+    ready: Promise<void>;
+    getCollection(name: string): DatabaseCollectionInterface;
+    close(): Promise<void>;
+}
+export interface DatabaseCollectionInterface {
+    name: string;
+    find(query?: object, projection?: Projection, options?: FindOptions): Observable<object[]>;
+    findSnapshot(query?: object, projection?: Projection, options?: FindOptions): Promise<object[]>;
+    update(query: object, update: object, multi?: boolean): Promise<void>;
+    upsert(query: object, update: object, multi?: boolean): Promise<void>;
+    remove(query: object, multi?: boolean): Promise<void>;
+    insert(docs: object[]): Promise<void>;
+    bulkWrite(operations: BulkWriteOperation<object>[], ordered?: boolean): Promise<void>;
+}
+export interface DocumentInterface {
+    _id: BinaryId;
+}
+export {};

package/core/src/litql/in-memory-database-collection.d.ts

@@ -0,0 +1,19 @@
+import { BulkWriteOperation } from "./bulk-write-operation.js";
+import { Observable } from "rxjs";
+import { DatabaseCollectionInterface, DocumentInterface, FindOptions, Projection } from "../index.js";
+export declare class InMemoryDatabaseCollection<T extends DocumentInterface = DocumentInterface> implements DatabaseCollectionInterface {
+    readonly name: string;
+    items: T[];
+    private readonly change;
+    constructor(name: string);
+    find(query?: object, projection?: Projection, options?: FindOptions): Observable<T[]>;
+    findSnapshot(query?: object, projection?: Projection, options?: FindOptions): Promise<T[]>;
+    insert(docs: T[]): Promise<void>;
+    remove(query: object, multi?: boolean): Promise<void>;
+    update(query: object, update: object, multi?: boolean): Promise<void>;
+    upsert(query: object, { $setOnInsert, ...update }: {
+        $setOnInsert: object;
+    }, multi?: boolean): Promise<void>;
+    bulkWrite(operations: BulkWriteOperation[], ordered?: boolean): Promise<void>;
+    private updateItems;
+}

package/core/src/litql/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./litql.js";
+export * from "./litql-query.js";
+export * from "./litql-types.js";
+export * from "../utils/iterable-utils.js";
+export * from "../utils/get-value-of.js";
+export * from "./database-interface.js";
+export * from "./bulk-write-operation.js";
+export * from "./in-memory-database-collection.js";

package/core/src/litql/litql-query.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from "rxjs";
+import { QueryResolution } from "./litql-types.js";
+import { DocumentInterface } from "./database-interface.js";
+export declare function executeQuery(resolution: QueryResolution): Observable<DocumentInterface[]>;

package/core/src/litql/litql-types.d.ts

@@ -0,0 +1,108 @@
+import { DatabaseCollectionInterface, SortOptions } from "./database-interface.js";
+import { LitQL } from "./litql.js";
+/**
+ * The type of the body of a query
+ */
+export type QueryBody = Record<string, QueryTypeBody>;
+/**
+ * The type of the value of a single type in a {@link QueryBody}
+ */
+export type QueryTypeBody = Record<string, QueryFieldBody | QueryOperatorBody>;
+/**
+ * The type of the value of a single field in a {@link QueryTypeBody}
+ */
+export type QueryFieldBody = Record<string, unknown> | 1;
+/**
+ * The type of the value of a single operator in a {@link QueryTypeBody}
+ */
+export type QueryOperatorBody = unknown;
+/**
+ * Additional options that can be passed to a LitQL query
+ */
+export interface QueryOptions {
+    /**
+     * If true, will only return a one-time snapshot of the query results and will NOT create a live query returning later
+     * updates.
+     */
+    once?: boolean;
+    /**
+     * Additional, custom values passed with the query. Most often used to pass values to hooks or fulfill functions
+     * (e.g. the current user).
+     */
+    context?: Record<string, unknown>;
+}
+export type JoinCardinality = "one" | "many";
+/**
+ * Describes a join side when specifying a database join using {@link registerJoin}
+ */
+export interface JoinPoint {
+    /**
+     * The name of the type on this joining side
+     */
+    type: string;
+    /**
+     * The name of the new field, that will contain the joined documents from the other side
+     */
+    field: string;
+    /**
+     * The field in this side of the join that must contain a matching value to the other side's joinField.
+     */
+    joinField: string;
+    /**
+     * Specifies the cardinality of this side, eg. one-to-many, one-to-one, many-to-many, etc.
+     */
+    joinType: JoinCardinality;
+}
+export interface JoinPointResolution {
+    joinPoint: RegisteredJoinPoint;
+    query: QueryResolution;
+}
+export interface RegisteredJoinPoint extends JoinPoint {
+    oppositeSide: JoinPoint;
+}
+/**
+ * A registered, queryable type
+ */
+export interface RegisteredCollection extends RegisterCollectionOptions {
+    joinPoints: Map<string, RegisteredJoinPoint>;
+}
+/**
+ * A resolved type with details
+ */
+export interface QueryResolution {
+    /**
+     * The type belonging to the resolution.
+     */
+    collection: RegisteredCollection;
+    /**
+     * A map of operators found in {@link body}. Keys are the operator names, values are the operator values
+     */
+    operators: Map<string, unknown>;
+    /**
+     * A set of projected fields found in {@link body}. Does not contain dynamic fields.
+     */
+    projection: Map<string, unknown>;
+    joinPoints: Map<string, JoinPointResolution>;
+    criteria: Record<string, unknown>;
+    isMulti: boolean;
+    isLive: boolean;
+    sort: SortOptions | null;
+    limit: number | null;
+    skip: number | null;
+    context: Record<string, unknown>;
+    litql: LitQL;
+    isFullProjection: boolean;
+}
+/**
+ * Options given to {@link registerCollection}
+ */
+export interface RegisterCollectionOptions {
+    /**
+     * @see {@link RegisterTypeOptions#name}
+     */
+    name: string;
+    /**
+     * The backing collection where the data presides
+     */
+    collection: DatabaseCollectionInterface;
+}