cry-synced-db-client 0.1.99 → 0.1.101

package/dist/index.js

@@ -6898,6 +6898,14 @@ var RestProxy = class {
     this._totalRequestMs = 0;
     this._requestCount = 0;
   }
+  /** Typed rdb2 operation call — exposes the full rdb2 API. */
+  async call(operation, payload, options) {
+    return this.restCall(
+      operation,
+      payload,
+      options
+    );
+  }
   async restCall(operation, payload = {}, options) {
     var _a, _b, _c;
     const timeout = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : this.defaultTimeoutMs;
@@ -7211,7 +7219,7 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.reconnectAttempt = 0;
     this.forcedOffline = false;
     this.subscribedChannels = /* @__PURE__ */ new Set();
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     this.wsUrl = config.wsUrl;
     this.dbName = config.dbName;
     this.collections = config.collections;
@@ -7225,6 +7233,8 @@ var Ebus2ProxyServerUpdateNotifier = class {
     if (config.onWsDisconnect) this.onWsDisconnectCallbacks.push(config.onWsDisconnect);
     if (config.onWsReconnect) this.onWsReconnectCallbacks.push(config.onWsReconnect);
     this.onWsNotification = config.onWsNotification;
+    this.subscribeServices = (_e = config.subscribeServices) != null ? _e : false;
+    this.onServicesChange = config.onServicesChange;
   }
   subscribe(callback) {
     this.callbacks.add(callback);
@@ -7358,6 +7368,9 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.reconnectAttempt = 0;
     this.currentReconnectDelay = this.reconnectDelayMs;
     this.sendSubscribe(`db/${this.dbName}`);
+    if (this.subscribeServices) {
+      this.sendSubscribe("ebus/services");
+    }
     this.startPingInterval();
     for (const callback of this.onWsConnectCallbacks) {
       try {
@@ -7417,6 +7430,14 @@ var Ebus2ProxyServerUpdateNotifier = class {
     }
   }
   handleChannelMessage(message) {
+    if (message.channel === "ebus/services" && this.onServicesChange) {
+      try {
+        this.onServicesChange(message.data);
+      } catch (err) {
+        console.error("onServicesChange callback failed:", err);
+      }
+      return;
+    }
     const prefix = `db/${this.dbName}/`;
     if (!message.channel.startsWith(prefix)) {
       return;

package/dist/src/db/Ebus2ProxyServerUpdateNotifier.d.ts

@@ -25,6 +25,15 @@ export interface Ebus2ProxyServerUpdateNotifierConfig {
     onWsReconnect?: (attempt: number) => void;
     /** Called when a notification is received */
     onWsNotification?: (payload: PublishDataPayload) => void;
+    /** Subscribe to ebus/services channel for worker presence */
+    subscribeServices?: boolean;
+    /** Called when ebus/services data changes (worker presence) */
+    onServicesChange?: (services: EbusService[]) => void;
+}
+export interface EbusService {
+    name: string;
+    workers: number;
+    requests: number;
 }
 export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNotifier {
     private wsUrl;
@@ -39,6 +48,8 @@ export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNot
     private onWsDisconnectCallbacks;
     private onWsReconnectCallbacks;
     private onWsNotification?;
+    private subscribeServices;
+    private onServicesChange?;
     private ws;
     private callbacks;
     private connected;

package/dist/src/db/RestProxy.d.ts

@@ -1,6 +1,7 @@
 import type { AggregateOptions, Timestamp } from "mongodb";
 import type { I_RestInterface, QuerySpec, QueryOpts, GetNewerSpec, BatchSpec, CollectionUpdateRequest, CollectionUpdateResult } from "../types/I_RestInterface";
 import type { Id } from "../types/DbEntity";
+import type { Rdb2CallMap, Rdb2Operation } from "../types/Rdb2CallMap";
 /** Progress callback for tracking upload progress */
 export type ProgressCallback = (sentBytes: number, totalBytes: number) => void;
 export interface RestProxyConfig {
@@ -93,6 +94,11 @@ export declare class RestProxy implements I_RestInterface {
     getRequestCount(): number;
     /** Reset timing stats */
     resetTimingStats(): void;
+    /** Typed rdb2 operation call — exposes the full rdb2 API. */
+    call<K extends Rdb2Operation, T = unknown>(operation: K, payload?: Rdb2CallMap[K], options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     private restCall;
     /** Combine multiple abort signals into one */
     private combineSignals;

package/dist/src/index.d.ts

@@ -6,6 +6,6 @@ export { DexieDb } from "./db/DexieDb";
 export { RestProxy } from "./db/RestProxy";
 export type { RestProxyConfig } from "./db/RestProxy";
 export { Ebus2ProxyServerUpdateNotifier } from "./db/Ebus2ProxyServerUpdateNotifier";
-export type { Ebus2ProxyServerUpdateNotifierConfig } from "./db/Ebus2ProxyServerUpdateNotifier";
+export type { Ebus2ProxyServerUpdateNotifierConfig, EbusService } from "./db/Ebus2ProxyServerUpdateNotifier";
 export { resolveConflict } from "./utils/conflictResolution";
 export { filterByQuery, matchesQuery, sortItems, applySkipLimit, projectItem, applyQueryOpts } from "./utils/localQuery";

package/dist/src/types/Rdb2CallMap.d.ts

@@ -0,0 +1,170 @@
+import type { AggregateOptions } from "mongodb";
+import type { Id } from "./DbEntity";
+import type { QuerySpec, QueryOpts, Projection, BatchSpec, UpsertOptions, GetNewerSpec, CollectionUpdateRequest } from "./I_RestInterface";
+/**
+ * Maps each rdb2 API operation to its payload shape.
+ * Derived from rdb2-api-spec.json — excludes disallowed
+ * server-only operations (close, createCollection, transactions, etc.).
+ */
+export interface Rdb2CallMap {
+    ping: {};
+    isConnected: {};
+    isOnReplicaSet: {};
+    getDatabases: {};
+    getDatabaseInfos: {};
+    getDb: {};
+    getCollections: {};
+    find: {
+        collection: string;
+        query?: QuerySpec<any>;
+        opts?: QueryOpts;
+    };
+    findOne: {
+        collection: string;
+        query: QuerySpec<any>;
+        projection?: Projection;
+        opts?: QueryOpts;
+    };
+    findAll: {
+        collection: string;
+        query?: QuerySpec<any>;
+        opts?: QueryOpts;
+    };
+    findById: {
+        collection: string;
+        id: Id;
+        projection?: Projection;
+        opts?: QueryOpts;
+    };
+    findByIds: {
+        collection: string;
+        ids: Id[];
+        projection?: Projection;
+        opts?: QueryOpts;
+    };
+    findByIdsInManyCollections: {
+        request: {
+            collection: string;
+            ids: Id[];
+        }[];
+        opts?: QueryOpts;
+    };
+    findNewer: {
+        collection: string;
+        timestamp: any;
+        query?: QuerySpec<any>;
+        opts?: QueryOpts;
+    };
+    findNewerMany: {
+        spec?: GetNewerSpec<any>[];
+    };
+    count: {
+        collection: string;
+        query?: QuerySpec<any>;
+        opts?: QueryOpts;
+    };
+    distinct: {
+        collection: string;
+        field: string;
+    };
+    aggregate: {
+        collection: string;
+        pipeline: object[];
+        opts?: AggregateOptions;
+    };
+    isUnique: {
+        collection: string;
+        field: string;
+        value: any;
+        id?: Id;
+    };
+    testHash: {
+        collection: string;
+        query: QuerySpec<any>;
+        field: string;
+        unhashedValue: string;
+    };
+    insert: {
+        collection: string;
+        insert: any;
+    };
+    insertMany: {
+        collection: string;
+        insert: any[];
+    };
+    save: {
+        collection: string;
+        update: any;
+        id?: Id;
+        options?: any;
+    };
+    update: {
+        collection: string;
+        query: QuerySpec<any>;
+        update: any;
+    };
+    updateOne: {
+        collection: string;
+        query: QuerySpec<any>;
+        update: any;
+        options?: any;
+    };
+    upsert: {
+        collection: string;
+        query: QuerySpec<any>;
+        update: any;
+        options?: UpsertOptions;
+    };
+    upsertBatch: {
+        collection: string;
+        batch: BatchSpec<any>;
+    };
+    updateCollections: {
+        collectionsBatches: CollectionUpdateRequest<any>[];
+    };
+    delete: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    deleteOne: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    hardDelete: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    hardDeleteOne: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    blockOne: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    unblockOne: {
+        collection: string;
+        query: QuerySpec<any>;
+    };
+    latestTimestamp: {
+        collection: string;
+    };
+    latestTimestamps: {
+        collections: string[];
+    };
+    resetCollectionSync: {
+        collection: string;
+    };
+    dbLogGet: {
+        collection: string;
+        id: Id;
+    };
+    dbLogPurge: {
+        collection: string;
+        id?: Id;
+    };
+    inTransaction: {};
+    newId: {};
+}
+/** Union of all allowed rdb2 operation names. */
+export type Rdb2Operation = keyof Rdb2CallMap;

package/dist/src/types/index.d.ts

@@ -7,3 +7,4 @@ export type { I_ServerUpdateNotifier as ServerUpdateNotifier, ServerUpdateCallba
 export type { I_SyncedDb as SyncedDb, SyncedDbConfig, CollectionConfig, CollectionSyncConfig, SyncInfo, ServerWriteRequestInfo, ServerWriteResultInfo, FindNewerManyCallInfo, FindNewerManyResultInfo, DexieWriteRequestInfo, DexieWriteResultInfo, LocalstorageWriteResultInfo, WsNotificationInfo, InfrastructureErrorType, InfrastructureErrorInfo, ConflictSource, ConflictResolutionReport, CrossTabSyncInfo, } from "./I_SyncedDb";
 export type { NetworkStatusChangeInfo } from "../db/types/managers";
 export type { CollectionConfig as CollectionConfigFull, CollectionSyncConfig as CollectionSyncConfigFull } from "./CollectionConfig";
+export type { Rdb2CallMap, Rdb2Operation } from "./Rdb2CallMap";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.99",
+  "version": "0.1.101",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",