@livequery/mongodb 2.0.145 → 2.0.148

package/README.md

@@ -314,33 +314,46 @@ MongoDB change stream watcher for realtime Livequery updates. This replaces the
 import { WebsocketGateway } from '@livequery/core'
 import { MongoDatasource, MongodbRealtime } from '@livequery/mongodb'
 
-const routes = [
+const datasource = new MongoDatasource({
+  connections: { default: client },
+  databases: ['main'],
+})
+
+await datasource.init([
   {
     method: 'GET',
     path: '/products',
     collection: 'products',
     realtime: true,
   },
-]
-
-const datasource = new MongoDatasource({
-  connections: { default: client },
-  databases: ['main'],
-})
-
-await datasource.init(routes)
+])
 
 const websocketGateway = new WebsocketGateway(server)
 
 new MongodbRealtime()
-  .watch(datasource.config, routes)
+  .watch(datasource.config, [
+    {
+      // LivequeryRequestParser.parse(...).schema — document-id segment already stripped
+      schema: 'products',
+      options: { collection: 'products', realtime: true },
+    },
+  ])
   .subscribe(websocketGateway)
 ```
 
+`MongoRealtimeRoute`:
+
+```ts
+type MongoRealtimeRoute = {
+  schema: string        // parsed route path from @livequery/core, e.g. 'users/:userId/posts'
+  options: RouteOptions
+}
+```
+
 Realtime route requirements:
 
-- `method` must be `GET` or legacy method `0`.
 - `realtime` must be `true`.
+- `schema` is the parsed route path (`LivequeryRequestParser.parse(...).schema`), so the document-id segment is already stripped and each `:param` names the document field holding the parent value.
 - `collection` must be a static string. Dynamic collection, database, or connection resolver functions are skipped because database watchers must be known up front.
 - When watching a `MongoClient`, `db` or `config.databases` decides which database names to watch. When watching a `Db`, that database is used directly.
 
@@ -352,20 +365,17 @@ Disable the `collMod` call when your deployment manages pre/post images separate
 new MongodbRealtime({ enablePreAndPostImages: false })
 ```
 
-For nested collection refs, use `refFields` to map route params to document fields:
+For nested collection refs, name the route param after the document field that holds the parent value:
 
 ```ts
 {
-  method: 'GET',
-  path: '/users/:id/posts',
-  collection: 'posts',
-  realtime: true,
-  refFields: {
-    id: 'userId',
-  },
+  schema: 'users/:userId/posts',
+  options: { collection: 'posts', realtime: true },
 }
 ```
 
+If the document field is an array (one document belongs to many parents), the change is fanned out to one ref per array element, and array membership changes emit `added`/`removed` per ref.
+
 An inserted `{ _id: 'post1', userId: 'user1', title: 'Hello' }` emits:
 
 ```ts
@@ -425,7 +435,6 @@ type RouteOptions = {
   collection: string | ((req: LivequeryRequest) => Promise<string> | string)
   db?: string | ((req: LivequeryRequest) => Promise<string> | string)
   connection?: string | ((req: LivequeryRequest) => Promise<string> | string)
-  refFields?: Record<string, string | { field: string, array?: boolean }>
   objectIdFields?: string[]
 }
 ```
@@ -436,7 +445,6 @@ Fields:
 - `collection`: required collection name or resolver function.
 - `db`: optional database name or resolver function.
 - `connection`: optional connection name or resolver function.
-- `refFields`: optional mapping from nested route params to document fields for realtime ref formatting.
 - `objectIdFields`: top-level request fields that should be converted from valid string ids to `ObjectId`.
 
 Use function values when tenant, database, or collection depends on request keys.

package/build/src/Cursor.d.ts

@@ -1,5 +1,4 @@
-import type { LivequeryBaseEntity, QueryOption } from "./types.js";
 export declare class Cursor {
-    static caculate<T extends LivequeryBaseEntity>(item: T, options: QueryOption<T>): string;
-    static parse<T extends LivequeryBaseEntity>(cursor: string): any;
+    static caculate(item: Record<string, any>, options: Record<string, any>): string;
+    static parse(cursor: string): any;
 }

package/build/src/MongoDatasource.d.ts

@@ -1,15 +1,7 @@
 import type { LivequeryContext, LivequeryDatasource as CoreLivequeryDatasource, LivequeryDatasourceInitConfig } from '@livequery/core';
-import type { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload } from './types.js';
+import type { LivequeryRequest, LivequeryBaseEntity, UpdatedData } from '@livequery/core';
 import type { Db, MongoClient } from 'mongodb';
 import { Subject } from 'rxjs';
-export type LivequeryDatasource<Config, RouteOptions> = Subject<WebsocketSyncPayload<LivequeryBaseEntity>> & {
-    init(config: Config, routes: Array<{
-        path: string;
-        method: number;
-        options: RouteOptions;
-    }>): Promise<void>;
-    query: (query: LivequeryRequest, options: RouteOptions) => Promise<any>;
-};
 export type MongoConnection = MongoClient | Db;
 export type MongoDatasourceConfig = {
     connections: {
@@ -17,31 +9,20 @@ export type MongoDatasourceConfig = {
     };
     databases?: string[];
 };
-type LegacyRouteConfig<RouteOptions> = {
-    path: string;
-    method: number | string;
-    options?: RouteOptions;
-    config?: RouteOptions;
-};
 export type RouteOptions = {
     realtime?: boolean;
     collection: string | ((req: LivequeryRequest) => Promise<string> | string);
     db?: string | ((req: LivequeryRequest) => Promise<string> | string);
     connection?: string | ((req: LivequeryRequest) => Promise<string> | string);
-    refFields?: Record<string, string | {
-        field: string;
-        array?: boolean;
-    }>;
     objectIdFields?: string[];
 };
-export declare class MongoDatasource extends Subject<WebsocketSyncPayload<LivequeryBaseEntity>> implements LivequeryDatasource<MongoDatasourceConfig, RouteOptions>, CoreLivequeryDatasource<RouteOptions> {
+export declare class MongoDatasource extends Subject<UpdatedData<LivequeryBaseEntity>> implements CoreLivequeryDatasource<RouteOptions> {
     #private;
     readonly refs: Map<string, Set<string>>;
     config: MongoDatasourceConfig;
     routes: Map<string, RouteOptions>;
     constructor(config?: MongoDatasourceConfig);
     init(routes: Array<LivequeryDatasourceInitConfig<RouteOptions>>): Promise<void>;
-    init(config: MongoDatasourceConfig, routes: Array<LegacyRouteConfig<RouteOptions>>): Promise<void>;
     handle(ctx: LivequeryContext): Promise<{}>;
     query(req: LivequeryRequest, options: RouteOptions): Promise<{
         items: any[];
@@ -68,4 +49,3 @@ export declare class MongoDatasource extends Subject<WebsocketSyncPayload<Livequ
         item: any;
     }>;
 }
-export {};

package/build/src/MongoDatasource.js

@@ -1,6 +1,6 @@
 import { Cursor } from './Cursor.js';
 import { MongoQuery } from "./MongoQuery.js";
-import { ObjectId } from 'bson';
+import { ObjectId } from 'mongodb';
 import { SmartCache } from './SmartCache.js';
 import { Subject } from 'rxjs';
 export class MongoDatasource extends Subject {
@@ -14,23 +14,18 @@ export class MongoDatasource extends Subject {
             this.config = config;
         this.routes = new Map();
     }
-    async init(configOrRoutes, maybeRoutes) {
-        const routes = Array.isArray(configOrRoutes)
-            ? configOrRoutes
-            : maybeRoutes || [];
-        if (!Array.isArray(configOrRoutes)) {
-            this.config = configOrRoutes;
-        }
+    async init(routes) {
         this.routes = routes.reduce((p, c) => {
-            const options = this.#getRouteOptions(c);
-            if (!options.collection)
+            const { method, path, ...options } = c;
+            const routeOptions = options;
+            if (!routeOptions.collection)
                 return p;
             const key = this.#routeKey(c.method, c.path);
             const set = p.get(key) || p.get(c.path);
-            if (set && set.collection != options.collection)
+            if (set && set.collection != routeOptions.collection)
                 throw new Error('Collection mismatch for route path "' + c.path + '"');
-            p.set(key, options);
-            p.set(c.path, options);
+            p.set(key, routeOptions);
+            p.set(c.path, routeOptions);
             return p;
         }, new Map());
     }
@@ -59,15 +54,6 @@ export class MongoDatasource extends Subject {
             return this.#del(query, collection);
         throw { status: 500, code: 'INVAILD_METHOD', message: 'Invaild method' };
     }
-    #getRouteOptions(route) {
-        const legacy = route;
-        if (legacy.options)
-            return legacy.options;
-        if (legacy.config)
-            return legacy.config;
-        const { method, path, ...options } = route;
-        return options;
-    }
     #getOptions(ctx) {
         const routePath = ctx.request.ref || ctx.request.path;
         const options = this.routes.get(this.#routeKey(ctx.request.method, routePath)) || this.routes.get(routePath);
@@ -87,23 +73,20 @@ export class MongoDatasource extends Subject {
             is_collection: !livequery.document_id,
             collection_ref: livequery.collection_ref,
             schema_collection_ref: livequery.schema_collection_ref,
-            doc_id: livequery.document_id,
+            document_id: livequery.document_id,
             keys: livequery.keys || {},
             query: livequery.query || {},
-            options: livequery.query || {},
             method: livequery.method?.toLowerCase(),
             body: livequery.body,
         };
     }
     #normalizeRequest(req) {
-        const options = req.options || req.query || {};
+        const query = req.query || {};
         return {
             ...req,
             keys: req.keys || {},
-            query: req.query || options,
-            options,
+            query,
             is_collection: typeof req.is_collection == 'boolean' ? req.is_collection : !req.document_id,
-            doc_id: req.doc_id || req.document_id,
             method: req.method?.toLowerCase(),
         };
     }
@@ -128,8 +111,8 @@ export class MongoDatasource extends Subject {
         const total = current + count.next + count.prev;
         const paging = {
             cursor: {
-                last: Cursor.caculate(items[items.length - 1], req.options),
-                first: Cursor.caculate(items[0], req.options)
+                last: Cursor.caculate(items[items.length - 1], req.query),
+                first: Cursor.caculate(items[0], req.query)
             },
             has,
             count: {
@@ -201,7 +184,7 @@ export class MongoDatasource extends Subject {
         const keys = req.keys || {};
         const isPlainBody = req.body && typeof req.body === 'object'
             && !Object.keys(req.body).some(k => k.startsWith('$'));
-        const id = keys.id ?? req.doc_id;
+        const id = keys.id ?? req.document_id;
         return {
             ...keys,
             ...isPlainBody ? req.body : {},
@@ -213,13 +196,19 @@ export class MongoDatasource extends Subject {
             return {
                 ...p,
                 ...k == 'id' ? {
-                    _id: ObjectId.createFromHexString(req.keys.id)
+                    _id: this.#objectId('id', req.keys.id)
                 } : {
                     [k]: c
                 }
             };
         }, {});
     }
+    #objectId(field, value) {
+        if (typeof value != 'string' || !ObjectId.isValid(value)) {
+            throw { status: 400, code: 'INVALID_OBJECT_ID', message: `Invalid ObjectId for field "${field}": ${JSON.stringify(value)}` };
+        }
+        return ObjectId.createFromHexString(value);
+    }
     #update(body) {
         if (!body || Object.keys(body).some(key => key.startsWith('$')))
             return body;

package/build/src/MongoQuery.d.ts

@@ -1,4 +1,4 @@
-import type { LivequeryBaseEntity, LivequeryRequest } from "./types.js";
+import type { LivequeryBaseEntity, LivequeryRequest } from "@livequery/core";
 import type { Collection } from "mongodb";
 export declare class MongoQuery {
     #private;

package/build/src/MongoQuery.js

@@ -1,5 +1,5 @@
 import { Cursor } from "./Cursor.js";
-import { ObjectId } from "bson";
+import { ObjectId } from "mongodb";
 export class MongoQuery {
     static #is_operator(c) {
         return ['+', '-', '*', '/', '(', ')', '~'].indexOf(c) !== -1;
@@ -94,6 +94,20 @@ export class MongoQuery {
     static #escape_regex(value) {
         return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
+    static #objectId(field, value) {
+        if (typeof value != 'string' || !ObjectId.isValid(value)) {
+            throw { status: 400, code: 'INVALID_OBJECT_ID', message: `Invalid ObjectId for field "${field}": ${JSON.stringify(value)}` };
+        }
+        return ObjectId.createFromHexString(value);
+    }
+    static #parse_cursor(token) {
+        try {
+            return Cursor.parse(token);
+        }
+        catch {
+            throw { status: 400, code: 'INVALID_CURSOR', message: 'Invalid pagination cursor' };
+        }
+    }
     static #parse_array(value) {
         if (Array.isArray(value))
             return value;
@@ -109,7 +123,7 @@ export class MongoQuery {
     }
     static #parse_summary(req) {
         const parsed = Object
-            .entries(req.options)
+            .entries(req.query)
             .map(([key, v], index) => {
             if (!key.startsWith('::'))
                 return [];
@@ -278,11 +292,11 @@ export class MongoQuery {
         return { $and: clauses };
     }
     static #build_search_query(req) {
-        const search = req.options[":search"];
+        const search = req.query[":search"];
         return search ? [{ $match: { $text: { $search: `${search}` } } }] : [];
     }
     static #get_limit(req) {
-        const l = Number(req.options[':limit']);
+        const l = Number(req.query[':limit']);
         if (isNaN(l))
             return 10;
         if (l < 1)
@@ -300,13 +314,19 @@ export class MongoQuery {
             }
         ];
     }
+    static #topn_sorter($sort) {
+        return Object.entries($sort).reduce((p, [key, order]) => ({
+            ...p,
+            [key == '_id' ? 'id' : key]: order
+        }), {});
+    }
     static #build_cursor_query($sort, req, reverse = false) {
         const limit = this.#get_limit(req);
-        const after = req.options[':after'];
-        const before = req.options[':before'];
-        const around = req.options[':around'];
+        const after = req.query[':after'];
+        const before = req.query[':before'];
+        const around = req.query[':around'];
         const pagination_token = around || before || after;
-        const cursor = pagination_token ? Cursor.parse(pagination_token) : (reverse ? null : {});
+        const cursor = pagination_token ? this.#parse_cursor(pagination_token) : (reverse ? null : {});
         if (!cursor)
             return [{ $limit: 1 }, { $match: { _id: 0 } }];
         const $or = Object.entries({ ...$sort, _id: $sort._id || -1 }).map(([key, order], index, arr) => {
@@ -341,7 +361,7 @@ export class MongoQuery {
                         items: {
                             [reverse ? '$bottomN' : '$topN']: {
                                 n: limit,
-                                sortBy: {},
+                                sortBy: this.#topn_sorter($sort),
                                 output: "$$ROOT"
                             }
                         }
@@ -360,7 +380,7 @@ export class MongoQuery {
         ];
     }
     static #build_cursor_paging($sort, req) {
-        if (req.options[':after'] || req.options[':before'] || req.options[':around']) {
+        if (req.query[':after'] || req.query[':before'] || req.query[':around']) {
         }
         const { pipelines, summary } = this.#parse_summary(req);
         const limit = this.#get_limit(req);
@@ -409,7 +429,7 @@ export class MongoQuery {
     }
     static #build_offset_paging(req) {
         const limit = this.#get_limit(req);
-        const page = Math.max(1, Math.floor(Number(req.options[':page'])) || 1);
+        const page = Math.max(1, Math.floor(Number(req.query[':page'])) || 1);
         const skip = (page - 1) * limit;
         const { pipelines, summary } = this.#parse_summary(req);
         return [
@@ -444,12 +464,12 @@ export class MongoQuery {
         ];
     }
     static #build_query_filter(req) {
-        const { ":after": after, ":before": before, ':around': around, ":limit": _limit, ":page": _page, ":search": search, ...rest } = req.options;
+        const { ":after": after, ":before": before, ':around': around, ":limit": _limit, ":page": _page, ":search": search, ...rest } = req.query;
         return this.#parse_conditions({ ...rest, ...req.keys });
     }
     static #get_sorter(req) {
         let default_sort = -1;
-        const $sort = Object.entries(req.options).reduce((p, [k, order]) => {
+        const $sort = Object.entries(req.query).reduce((p, [k, order]) => {
             if (!k.endsWith(':sort'))
                 return p;
             const by = k.split(':sort')[0];
@@ -474,7 +494,7 @@ export class MongoQuery {
                 {
                     $match: {
                         ...req.keys,
-                        ...req.keys.id ? { id: undefined, _id: ObjectId.createFromHexString(req.keys.id) } : {}
+                        ...req.keys.id ? { id: undefined, _id: this.#objectId('id', req.keys.id) } : {}
                     }
                 },
                 ...this.#rename_id(),
@@ -493,7 +513,7 @@ export class MongoQuery {
                 summary: {}
             };
         }
-        const is_cursor_paging = req.options[':after'] || req.options[':before'] || req.options[':around'] || !req.options[':page'];
+        const is_cursor_paging = req.query[':after'] || req.query[':before'] || req.query[':around'] || !req.query[':page'];
         const $sort = this.#get_sorter(req);
         const pipelines = [
             { $sort },

package/build/src/MongodbRealtime.d.ts

@@ -1,23 +1,17 @@
 import { Observable } from 'rxjs';
-import type { WebsocketSyncPayload } from './types.js';
+import type { UpdatedData } from '@livequery/core';
 import type { MongoDatasourceConfig, RouteOptions } from './MongoDatasource.js';
 export type MongoRealtimeChangeType = 'added' | 'modified' | 'removed';
-export type MongoRealtimeRefField = string | {
-    field: string;
-    array?: boolean;
-};
 export type MongoRealtimeOptions = {
     enablePreAndPostImages?: boolean;
 };
 export type MongoRealtimeRoute = {
-    path: string;
-    method: string | number;
-    options?: RouteOptions;
-    config?: RouteOptions;
-} & Partial<RouteOptions>;
+    schema: string;
+    options: RouteOptions;
+};
 export declare class MongodbRealtime {
     #private;
     private options;
     constructor(options?: MongoRealtimeOptions);
-    watch(config: MongoDatasourceConfig, routes: MongoRealtimeRoute[]): Observable<WebsocketSyncPayload>;
+    watch(config: MongoDatasourceConfig, routes: MongoRealtimeRoute[]): Observable<UpdatedData<any>>;
 }

package/build/src/MongodbRealtime.js

@@ -23,17 +23,6 @@ export class MongodbRealtime {
             }, {}),
         };
     }
-    #isGetRoute(method) {
-        return method === 0 || String(method).toUpperCase() === 'GET';
-    }
-    #getRouteOptions(route) {
-        if (route.options)
-            return route.options;
-        if (route.config)
-            return route.config;
-        const { method: _method, path: _path, options: _options, config: _config, ...options } = route;
-        return options.collection ? options : undefined;
-    }
     #isDb(connection) {
         return typeof connection.collection == 'function';
     }
@@ -45,8 +34,8 @@ export class MongodbRealtime {
     #watchSources(config, routes) {
         const sources = new Map();
         for (const route of routes) {
-            const options = this.#getRouteOptions(route);
-            if (!options?.realtime || !this.#isGetRoute(route.method))
+            const options = route.options;
+            if (!options?.realtime)
                 continue;
             if (typeof options.collection != 'string')
                 continue;
@@ -99,7 +88,7 @@ export class MongodbRealtime {
                         table: change.ns.coll,
                         type,
                         new_data: this.#reformatId(change.fullDocument),
-                        old_data: this.#reformatId(change.fullDocumentBeforeChange),
+                        old_data: this.#reformatId(change.fullDocumentBeforeChange ?? change.documentKey),
                         fields,
                     });
                 });
@@ -110,35 +99,31 @@ export class MongodbRealtime {
         }), mergeMap(stream => stream), retry());
     }
     #routeRefMetadata(route) {
-        const options = this.#getRouteOptions(route);
-        if (!options?.realtime || !this.#isGetRoute(route.method))
+        const options = route.options;
+        if (!options?.realtime)
             return;
         if (typeof options.collection != 'string')
             return;
-        const segments = route.path.split('/').filter(Boolean);
-        const collectionSegments = segments.length % 2 === 0 ? segments.slice(0, -1) : segments;
-        const ref = collectionSegments.map(segment => segment.startsWith(':') ? '' : segment).filter(Boolean).join('/');
+        const segments = route.schema.split('/').filter(Boolean);
+        const ref = segments.filter(segment => !segment.startsWith(':')).join('/');
         if (!ref)
             return;
-        const metadata = collectionSegments
+        const metadata = segments
             .map((collection, index) => {
             if (index % 2 === 1)
                 return [];
-            const param = collectionSegments[index + 1];
+            const param = segments[index + 1];
             if (!param?.startsWith(':'))
                 return [{ collection }];
-            const paramName = param.slice(1);
-            const mapped = options.refFields?.[paramName] || paramName;
-            const field = typeof mapped == 'string' ? mapped : mapped.field;
-            const array = typeof mapped == 'string' ? undefined : mapped.array;
-            return [{ collection, field: field == 'id' ? '_id' : field, array }];
+            const field = param.slice(1);
+            return [{ collection, field: field == 'id' ? '_id' : field }];
         })
             .flat();
         return [ref, metadata];
     }
     #paths(routes) {
         return routes.reduce((paths, route) => {
-            const options = this.#getRouteOptions(route);
+            const options = route.options;
             const entry = this.#routeRefMetadata(route);
             if (!options || !entry || typeof options.collection != 'string')
                 return paths;
@@ -179,16 +164,16 @@ export class MongodbRealtime {
                 return 'removed';
             return 'modified';
         };
-        const buildRefs = ([{ array, collection, field }, ...fields]) => {
+        const buildRefs = ([{ collection, field }, ...fields]) => {
             if (fields.length === 0 || !field)
                 return [{ refs: [collection], type: event.type }];
-            const values = array
-                ? Array.isArray(merged[field])
-                    ? [...new Set([
-                            ...(event.old_data?.[field]?.map((item) => String(item)) || []),
-                            ...(event.new_data?.[field]?.map((item) => String(item)) || []),
-                        ])]
-                    : ['-']
+            const oldValues = event.old_data?.[field];
+            const newValues = event.new_data?.[field];
+            const values = Array.isArray(oldValues) || Array.isArray(newValues)
+                ? [...new Set([
+                        ...(Array.isArray(oldValues) ? oldValues : []).map((item) => String(item)),
+                        ...(Array.isArray(newValues) ? newValues : []).map((item) => String(item)),
+                    ])]
                 : [merged[field] ?? '-'];
             return values.flatMap(value => {
                 return buildRefs(fields).map(next => ({

package/build/src/index.d.ts

@@ -1,4 +1,3 @@
 export * from './MongoDatasource.js';
 export * from './DataChangePayload.js';
 export * from './MongodbRealtime.js';
-export * from './types.js';

package/build/src/index.js

@@ -1,4 +1,3 @@
 export * from './MongoDatasource.js';
 export * from './DataChangePayload.js';
 export * from './MongodbRealtime.js';
-export * from './types.js';

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongodatasource.ts","../src/mongoquery.ts","../src/mongodbrealtime.ts","../src/smartcache.ts","../src/index.ts","../src/types.ts"],"version":"5.9.3"}
+{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongodatasource.ts","../src/mongoquery.ts","../src/mongodbrealtime.ts","../src/smartcache.ts","../src/index.ts"],"version":"5.9.3"}

package/package.json

@@ -6,7 +6,7 @@
     "repository": {
         "url": "git@github.com:livequery/mongodb.git"
     },
-    "version": "2.0.145",
+    "version": "2.0.148",
     "description": "MongoDB datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",
@@ -34,7 +34,6 @@
         "deploy": "rm -rf build && yarn build; git add .; git commit -m \"Update\"; git push origin master; npm publish --access public"
     },
     "peerDependencies": {
-        "bson": "*",
         "mongodb": "^6.20.0"
     }
 }

package/build/src/types.d.ts

@@ -1,46 +0,0 @@
-import type { LivequeryRequest as CoreLivequeryRequest } from '@livequery/core';
-export type LivequeryBaseEntity = {
-    id?: string;
-    [key: string]: any;
-};
-export type QueryOption<T extends LivequeryBaseEntity = LivequeryBaseEntity> = Record<string, any>;
-export type FilterConditions<T extends LivequeryBaseEntity = LivequeryBaseEntity> = Record<string, any>;
-export type Paging = {
-    cursor: {
-        last: string | null;
-        first: string | null;
-    };
-    has: {
-        prev: boolean;
-        next: boolean;
-    };
-    count: {
-        prev: number;
-        next: number;
-        current: number;
-        total: number;
-    };
-    page: {
-        current: number;
-        total: number;
-    };
-};
-export type WebsocketSyncPayload<T extends LivequeryBaseEntity = LivequeryBaseEntity> = {
-    ref?: string;
-    type?: string;
-    data?: T;
-    [key: string]: any;
-};
-export type LivequeryRequest<T = any> = Partial<CoreLivequeryRequest<T>> & {
-    keys: Record<string, any>;
-    ref: string;
-    collection_ref?: string;
-    schema_collection_ref?: string;
-    method: string;
-    body?: T;
-    query?: Record<string, any>;
-    options: Record<string, any>;
-    is_collection: boolean;
-    doc_id?: string;
-    document_id?: string;
-};

package/build/src/types.js

@@ -1 +0,0 @@
-export {};