@zuzjs/flare 0.2.14 → 0.2.16

package/dist/index-BAvE1URE.d.cts

@@ -0,0 +1,511 @@
+import { AuthToken } from '@zuzjs/auth';
+
+/**
+ * Client Configuration
+ */
+interface FlareConfig {
+    /** Base URL for the Flare API. */
+    endpoint: string;
+    /** Optional gRPC endpoint, e.g. "127.0.0.1:5051" for Node runtimes. */
+    grpcUrl?: string;
+    /** Transport preference for supported operations. */
+    transport?: "auto" | "ws" | "http" | "grpc";
+    /**
+     * Optional HTTP base URL for auth API calls.
+     * When set, all auth HTTP calls go through this base instead of calling
+     * Flare directly. Use this to route calls through a Next.js proxy so CSRF
+     * is handled entirely server-side.
+     * Example: '/api/flare'  (relative, browser resolves against current origin)
+     */
+    httpBase?: string;
+    /**
+     * WebSocket path used for realtime transport.
+     * Defaults to '/' for backward compatibility.
+     */
+    wsPath?: string;
+    /** Unique identifier for the application. */
+    appId: string;
+    /** API key for the application. */
+    apiKey?: string;
+    /**
+     * Request content type for credential auth endpoints (/auth/token, /auth/register).
+     * Defaults to OAuth-compatible form encoding.
+     */
+    authRequestContentType?: "application/x-www-form-urlencoded" | "application/json";
+    /**
+     * Controls how onAuthStateChanged initializes auth in browser runtime.
+     * - `refresh` (default): attempt /auth/refresh once in httpBase mode.
+     * - `none`: skip automatic refresh bootstrap; listeners receive current in-memory state only.
+     */
+    authBootstrapMode?: "refresh" | "none";
+    /** Public key for the application. */
+    publicKey?: string;
+    /** Whether to automatically reconnect on connection loss. */
+    autoReconnect?: boolean;
+    /** Delay between reconnection attempts in milliseconds. */
+    reconnectDelay?: number;
+    /** Maximum delay between reconnection attempts in milliseconds. */
+    maxReconnectDelay?: number;
+    /** Enable or disable debug mode. */
+    debug?: boolean;
+    /** Enable or disable request timing. */
+    requestTiming?: boolean;
+    /** Connection timeout in milliseconds. */
+    connectionTimeout?: number;
+    /** Enable automatic push notification registration on supported platforms. */
+    pushNotifications?: boolean;
+    /**
+     * Optional per-collection mapper registry for shaping inbound data.
+     *
+     * Keys can be:
+     * - base collection names (e.g. "boards")
+     * - join aliases (`join(..., { as: "team" })` => "team")
+     */
+    dataMapper?: DataMapperRegistry;
+}
+type DataMapperFn<TRow = any, TMapped = any> = (row: TRow) => TMapped;
+type DataMapperRegistry = Record<string, DataMapperFn<any, any>>;
+type FlareAuthProviderId = "credentials" | "anonymous" | "google" | "facebook" | "github" | "dropbox" | "apple" | "twitter";
+interface FlareAuthProviderPublicConfig {
+    enabled: boolean;
+    clientId?: string;
+    scopes?: string[];
+}
+interface FlareAuthConfig {
+    appId: string;
+    enabled: boolean;
+    needsEmailVerification?: boolean;
+    autoSendVerificationEmail?: boolean;
+    redirectUri?: string;
+    csrfToken?: string;
+    cookie?: {
+        accessTokenName?: string;
+        refreshTokenName?: string;
+        csrfTokenName?: string;
+        domain?: string;
+        path?: string;
+        secure?: boolean;
+        sameSite?: "Lax" | "Strict" | "None";
+        accessTokenMaxAge?: number;
+        refreshTokenMaxAge?: number;
+        csrfTokenMaxAge?: number;
+    };
+    providers: Record<FlareAuthProviderId, FlareAuthProviderPublicConfig>;
+}
+interface FlareAuthSession {
+    uid: string;
+    accessToken: string;
+    refreshToken: string | null;
+    provider?: string;
+    email?: string | null;
+    emailVerified?: boolean;
+}
+interface FlareAuthUser {
+    uid: string;
+    email: string;
+    email_verified: string;
+    [x: string]: any;
+}
+interface FlareAuthHydrationInput {
+    uid?: string | null;
+    id?: string | null;
+    accessToken?: string | null;
+    refreshToken?: string | null;
+    ticket?: string | null;
+    provider?: string;
+    email?: string | null;
+    emailVerified?: boolean;
+    email_verified?: boolean;
+    profile?: Partial<FlareAuthUser> | null;
+}
+interface FlareAuthHydrationOptions {
+    source?: string;
+    markBootstrapAttempted?: boolean;
+    syncSocket?: boolean;
+}
+interface RegisterPushTokenInput {
+    token: string;
+    platform?: string;
+    deviceId?: string;
+    topics?: string[];
+    authAppId?: string;
+}
+interface BrowserPushTokenOptions {
+    /** Service worker registration used for PushManager subscription. */
+    serviceWorkerRegistration?: ServiceWorkerRegistration;
+    /** Existing PushSubscription to reuse instead of subscribing again. */
+    subscription?: PushSubscription;
+    /** Public VAPID key used when creating a new PushSubscription. */
+    applicationServerKey?: string;
+    /** When true, unsubscribe old subscriptions before creating a new one. */
+    forceResubscribe?: boolean;
+}
+interface BrowserPushRegistrationOptions extends BrowserPushTokenOptions {
+    /** Optional explicit platform label. Defaults to "web". */
+    platform?: string;
+    deviceId?: string;
+    topics?: string[];
+    authAppId?: string;
+}
+interface SendPushNotificationInput {
+    title?: string;
+    body?: string;
+    image?: string;
+    data?: Record<string, unknown>;
+    tokens?: string[];
+    uid?: string;
+    topic?: string;
+    priority?: "normal" | "high";
+    ttlSeconds?: number;
+    dryRun?: boolean;
+    authAppId?: string;
+}
+interface PushSendResult {
+    sent: boolean;
+    appId: string;
+    targetCount: number;
+    successCount: number;
+    failureCount: number;
+    invalidatedTokenCount: number;
+    dryRun: boolean;
+}
+interface SendEmailInput {
+    to: string | string[];
+    tag: string;
+    values?: Record<string, unknown>;
+    authAppId?: string;
+}
+interface EmailSendResult {
+    sent: boolean;
+    appId: string;
+    tag: string;
+    recipientCount: number;
+    acceptedCount: number;
+    rejectedCount: number;
+    includeVerificationLink?: boolean;
+    linkId?: string;
+    verifyUrl?: string;
+    messageId?: string;
+}
+interface VerifyEmailLinkInput {
+    token: string;
+    tag?: string;
+    email?: string;
+    authAppId?: string;
+}
+interface EmailLinkVerifyResult {
+    verified: boolean;
+    alreadyVerified: boolean;
+    appId: string;
+    linkId: string;
+    email: string;
+    tag: string;
+    verifiedAt?: string;
+    acceptedByUid?: string;
+}
+type AuthStateListener = (session: FlareAuthSession & FlareAuthUser | null) => void;
+type AuthConfigListener = (conf: FlareAuthConfig) => void;
+interface SubscribeOptions {
+    skipSnapshot?: boolean;
+}
+type QueryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "array-contains" | "array-contains-any" | "elem-match" | "like" | "not-like" | "contains" | "exists" | "not-exists";
+interface QueryConfig {
+    field: string;
+    op: QueryOperator;
+    value: unknown;
+}
+/** OR group */
+interface OrFilter {
+    or: AnyFilter[];
+}
+/** AND group */
+interface AndFilter {
+    and: AnyFilter[];
+}
+type AnyFilter = QueryConfig | OrFilter | AndFilter;
+type WhereCondition = Record<string, string | number | boolean | any[]>;
+interface OrderByClause {
+    field: string;
+    dir?: "asc" | "desc";
+}
+interface GroupByClause {
+    fields: string[];
+}
+interface HavingClause {
+    field: string;
+    op: "==" | "!=" | "<" | "<=" | ">" | ">=";
+    value: number;
+}
+interface CursorValue {
+    values: unknown[];
+}
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "distinct";
+interface AggregateSpec {
+    fn: AggregateFunction;
+    field?: string;
+    alias?: string;
+}
+/**
+ * Join definition used by CollectionReference.Join().
+ *
+ * Example:
+ *   Join("tasks", { source: "id", target: "boardId", as: "tasks" })
+ */
+interface JoinQueryPattern {
+    where?: AnyFilter[];
+    orderBy?: OrderByClause[];
+    limit?: number;
+    offset?: number;
+    startAt?: CursorValue;
+    startAfter?: CursorValue;
+    endAt?: CursorValue;
+    endBefore?: CursorValue;
+    aggregate?: AggregateSpec[];
+    groupBy?: GroupByClause;
+    having?: HavingClause[];
+    vectorSearch?: VectorSearchClause;
+    select?: string[];
+    distinctField?: string;
+}
+interface NestedJoinClause extends JoinQueryPattern {
+    /** Joined collection name for this nested join. */
+    collection: string;
+    /** Field from the parent join result. */
+    source: string;
+    /** Field from this nested collection to match source. */
+    target: string;
+    /** Alias where nested rows are attached in each parent join row. */
+    as: string;
+    /** If true, expect at most one joined row. */
+    single?: boolean;
+    /** Recursive nested joins. */
+    joins?: NestedJoinClause[];
+}
+interface JoinClause extends JoinQueryPattern {
+    /** Field from the base collection (the collection you started the query on). */
+    source: string;
+    /** Field from the joined collection that should match source. */
+    target: string;
+    /** Alias where joined rows will be attached in each result object. */
+    as: string;
+    /** If true, expect at most one joined row (object instead of array on server side). */
+    single?: boolean;
+    /** Optional nested joins under this join. */
+    joins?: NestedJoinClause[];
+}
+/** Internal wire-ready join shape sent to server query engine. */
+interface StructuredJoinClause extends JoinQueryPattern {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as: string;
+    single?: boolean;
+    joins?: StructuredJoinClause[];
+}
+interface VectorSearchClause {
+    field: string;
+    vector: number[];
+    k: number;
+    metric?: "cosine" | "euclidean" | "dotProduct";
+    minScore?: number;
+}
+/** Full structured query (document query + SQL-style feature set) */
+interface StructuredQuery {
+    where?: AnyFilter[];
+    orderBy?: OrderByClause[];
+    limit?: number;
+    offset?: number;
+    startAt?: CursorValue;
+    startAfter?: CursorValue;
+    endAt?: CursorValue;
+    endBefore?: CursorValue;
+    aggregate?: AggregateSpec[];
+    groupBy?: GroupByClause;
+    having?: HavingClause[];
+    joins?: StructuredJoinClause[];
+    vectorSearch?: VectorSearchClause;
+    select?: string[];
+    distinctField?: string;
+}
+type QueryPresetSpec<Params extends Record<string, unknown> = Record<string, unknown>, Row = any> = {
+    params: Params;
+    row: Row;
+};
+type QueryPresetMap = Record<string, QueryPresetSpec<any, any>>;
+type QueryPresetParams<TSpec> = TSpec extends QueryPresetSpec<infer Params, any> ? Params : Record<string, unknown>;
+type QueryPresetRow<TSpec> = TSpec extends QueryPresetSpec<any, infer Row> ? Row : any;
+type ChangeOperation = 'insert' | 'update' | 'replace' | 'delete';
+/**
+ * Fired once when the subscription is first established.
+ * `data` is always an array — the full matching collection snapshot.
+ */
+interface SnapshotEvent<T = any> {
+    type: 'snapshot';
+    subscriptionId: string;
+    collection: string;
+    data: T[];
+}
+/**
+ * Fired on every subsequent document mutation that matches the subscription query.
+ * `data` is the single affected document (null on delete).
+ */
+interface ChangeEvent<T = any> {
+    type: 'change';
+    subscriptionId: string;
+    collection: string;
+    docId: string;
+    operation: ChangeOperation;
+    data: T | null;
+}
+/** Discriminated union — narrow on `event.type` to get the right shape. */
+type SubscriptionData<T = any> = SnapshotEvent<T> | ChangeEvent<T>;
+type SubscriptionCallback<T = any> = (data: SubscriptionData<T>) => void;
+interface SubscriptionError {
+    code?: string;
+    message: string;
+    permissionDenied: boolean;
+    raw?: unknown;
+}
+type SubscriptionErrorCallback = (error: SubscriptionError) => void;
+interface SubscriptionHandle {
+    (): void;
+    unsubscribe: () => void;
+    onError: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+    onPermissionDenied: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+    catch: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+}
+type DocAddedCallback<T = any> = (data: T, docId: string) => void;
+type DocUpdatedCallback<T = any> = (data: T, docId: string) => void;
+type DocDeletedCallback<T = any> = (docId: string) => void;
+type DocChangedCallback<T = any> = (data: T | null, docId: string, operation: ChangeOperation) => void;
+type StreamFlushReason = 'snapshot' | 'change-batch';
+interface CollectionStreamOptions<T = any> {
+    /** Delay before a queued burst is flushed to listeners. */
+    flushMs?: number;
+    /** Flush immediately when queued changes reach this count. */
+    maxBatchSize?: number;
+    /** Field used to identify docs inside snapshots when getId is not provided. */
+    idField?: keyof T & string;
+    /** Custom identifier extractor for snapshot rows. */
+    getId?: (doc: T) => string | undefined;
+    /** Where newly inserted docs should be placed when they were not in snapshot. */
+    insertAt?: 'start' | 'end';
+    /** Optional cap to keep only the newest N docs in local stream state. */
+    maxDocs?: number;
+    /** Optional local sort run after flush. */
+    sort?: (a: T, b: T) => number;
+}
+interface CollectionStreamMeta {
+    reason: StreamFlushReason;
+    batchSize: number;
+    version: number;
+    ready: boolean;
+}
+type CollectionStreamListener<T = any> = (rows: readonly T[], meta: CollectionStreamMeta) => void;
+interface CollectionStream<T = any> {
+    /** Subscribe to stream updates (call unsubscribe to stop). */
+    subscribe: (listener: CollectionStreamListener<T>, emitCurrent?: boolean) => () => void;
+    /** Returns the latest immutable snapshot of rows. */
+    getSnapshot: () => readonly T[];
+    /** Returns true after the initial snapshot has been received. */
+    isReady: () => boolean;
+    /** Monotonic version incremented on each flush. */
+    getVersion: () => number;
+    /** Stop the underlying realtime subscription and cleanup timers/listeners. */
+    close: () => void;
+    /** Attach subscription-level error handler. */
+    onError: (callback: SubscriptionErrorCallback) => CollectionStream<T>;
+    /** Attach permission-denied handler. */
+    onPermissionDenied: (callback: SubscriptionErrorCallback) => CollectionStream<T>;
+}
+interface CollectionExternalStore<T = any> {
+    /** Standard external-store subscribe signature used by UI store hooks. */
+    subscribe: (onStoreChange: () => void) => () => void;
+    /** Returns current immutable rows snapshot. */
+    getSnapshot: () => readonly T[];
+    /** Server snapshot fallback for SSR-safe store hooks. */
+    getServerSnapshot: () => readonly T[];
+    /** Access to underlying realtime stream for advanced handlers. */
+    stream: CollectionStream<T>;
+    /** Stops realtime stream and detaches listeners. */
+    destroy: () => void;
+}
+interface DocumentSnapshot<T = any> {
+    id: string;
+    data: T | null;
+    exists: boolean;
+}
+interface QuerySnapshot<T = any> {
+    docs: DocumentSnapshot<T>[];
+    size: number;
+    empty: boolean;
+}
+interface OfflineOperation {
+    id: string;
+    type: 'write' | 'delete';
+    collection: string;
+    docId: string;
+    data?: Record<string, unknown>;
+    merge?: boolean;
+    clientTs: number;
+}
+interface AuthResult {
+    uid: string;
+    token?: string;
+}
+type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error';
+interface AuthWithPendingVerificationResult {
+    verificationRequired: true;
+    created: true;
+    emailSent: boolean;
+    preview?: {
+        code: string;
+        link: string;
+    };
+}
+interface AuthWithTokenResult extends AuthResult {
+    accessToken: string;
+    refreshToken: string | null;
+    authToken: AuthToken;
+    created: boolean;
+}
+interface PresenceMember {
+    uid: string;
+    socketId: string;
+    room: string;
+    meta?: Record<string, unknown>;
+    joinedAt: number;
+    lastSeen: number;
+}
+type PresenceCallback = (members: PresenceMember[]) => void;
+type PresenceJoinCallback = (member: PresenceMember) => void;
+type PresenceLeaveCallback = (uid: string) => void;
+/** Fields marked as vector will be auto-embedded before write */
+type VectorFieldConfig = {
+    /** Dimensions of the vector (e.g. 1536 for OpenAI ada-002) */
+    dimensions: number;
+    /** Optional custom embedding function; defaults to client-configured embedder */
+    embed?: (text: string) => Promise<number[]>;
+};
+type RulePermission = "create" | "read" | "update" | "delete";
+interface FlareRule {
+    id: string;
+    name: string;
+    auth: "any" | "guest" | "auth";
+    collection: string;
+    document?: string;
+    condition?: string;
+    permissions: RulePermission[];
+}
+interface SecurityRuleEntry {
+    ".read"?: string;
+    ".write"?: string;
+    ".create"?: string;
+    ".update"?: string;
+    ".delete"?: string;
+}
+type SecurityRulesMap = Record<string, SecurityRuleEntry>;
+declare const flareRulesToSecurityMap: (rules: FlareRule[]) => SecurityRulesMap;
+declare const securityMapToFlareRules: (rules: SecurityRulesMap) => FlareRule[];
+
+export { type QueryPresetMap as $, type AggregateFunction as A, type BrowserPushRegistrationOptions as B, type ChangeEvent as C, type DataMapperFn as D, type EmailLinkVerifyResult as E, type FlareConfig as F, type FlareAuthHydrationOptions as G, type FlareAuthProviderId as H, type FlareAuthProviderPublicConfig as I, type FlareAuthSession as J, type FlareAuthUser as K, type FlareRule as L, type GroupByClause as M, type HavingClause as N, type JoinClause as O, type JoinQueryPattern as P, type NestedJoinClause as Q, type OfflineOperation as R, type OrFilter as S, type OrderByClause as T, type PresenceCallback as U, type PresenceJoinCallback as V, type PresenceLeaveCallback as W, type PresenceMember as X, type PushSendResult as Y, type QueryConfig as Z, type QueryOperator as _, type AggregateSpec as a, type QueryPresetParams as a0, type QueryPresetRow as a1, type QueryPresetSpec as a2, type QuerySnapshot as a3, type RegisterPushTokenInput as a4, type RulePermission as a5, type SecurityRuleEntry as a6, type SecurityRulesMap as a7, type SendEmailInput as a8, type SendPushNotificationInput as a9, type SnapshotEvent as aa, type StreamFlushReason as ab, type StructuredJoinClause as ac, type StructuredQuery as ad, type SubscribeOptions as ae, type SubscriptionCallback as af, type SubscriptionData as ag, type SubscriptionError as ah, type SubscriptionErrorCallback as ai, type SubscriptionHandle as aj, type VectorFieldConfig as ak, type VectorSearchClause as al, type VerifyEmailLinkInput as am, type WhereCondition as an, flareRulesToSecurityMap as ao, securityMapToFlareRules as ap, type AndFilter as b, type AnyFilter as c, type AuthConfigListener as d, type AuthResult as e, type AuthStateListener as f, type AuthWithPendingVerificationResult as g, type AuthWithTokenResult as h, type BrowserPushTokenOptions as i, type ChangeOperation as j, type CollectionExternalStore as k, type CollectionStream as l, type CollectionStreamListener as m, type CollectionStreamMeta as n, type CollectionStreamOptions as o, type ConnectionState as p, type CursorValue as q, type DataMapperRegistry as r, type DocAddedCallback as s, type DocChangedCallback as t, type DocDeletedCallback as u, type DocUpdatedCallback as v, type DocumentSnapshot as w, type EmailSendResult as x, type FlareAuthConfig as y, type FlareAuthHydrationInput as z };