@livequery/mongoose 2.0.47 → 2.0.50

package/build/src/MongoQuery.js

@@ -1,5 +1,6 @@
 import { Cursor } from "./Cursor.js";
 import { ObjectId } from "bson";
+import { Types } from 'mongoose';
 export class MongoQuery {
     static #is_operator(c) {
         return ['+', '-', '*', '/', '(', ')', '~'].indexOf(c) !== -1;
@@ -203,37 +204,26 @@ export class MongoQuery {
                 return p;
             const [key, expression] = k.split(':');
             const map = {
-                eq: () => {
-                    if (value.toLowerCase() == 'null')
-                        return { $eq: null };
-                    if (value.toLowerCase() == 'true')
-                        return { $eq: true };
-                    if (value.toLowerCase() == 'false')
-                        return { $eq: false };
-                    if (!isNaN(Number(value)))
-                        return { $eq: Number(value) };
-                    return { $eq: value };
-                },
-                lt: () => ({ $lt: Number(value) }),
-                lte: () => ({ $lte: Number(value) }),
-                gt: () => ({ $gt: Number(value) }),
-                gte: () => ({ $gte: Number(value) }),
+                eq: () => ({ $eq: value }),
+                lt: () => ({ $lt: !isNaN(Number(value)) ? Number(value) : 0 }),
+                lte: () => ({ $lte: !isNaN(Number(value)) ? Number(value) : 0 }),
+                gt: () => ({ $gt: !isNaN(Number(value)) ? Number(value) : 0 }),
+                gte: () => ({ $gte: !isNaN(Number(value)) ? Number(value) : 0 }),
                 ne: () => {
-                    if (value.toLowerCase() == 'null')
-                        return { $ne: null };
-                    if (value.toLowerCase() == 'true')
-                        return { $ne: true };
-                    if (value.toLowerCase() == 'false')
-                        return { $ne: false };
-                    if (!isNaN(Number(value)))
-                        return { $ne: Number(value) };
                     return { $ne: value };
                 },
                 in: () => ({ $in: JSON.parse(value) }),
                 nin: () => ({ $nin: JSON.parse(value) }),
-                'eq-string': () => ({ $eq: value })
+                'eq-number': () => ({ $eq: !isNaN(Number(value)) ? Number(value) : 0 }),
+                'neq-number': () => ({ $ne: !isNaN(Number(value)) ? Number(value) : 0 }),
+                'eq-boolean': () => ({ $eq: `${value}`.toLowerCase() == 'true' ? true : false }),
+                'neq-boolean': () => ({ $ne: `${value}`.toLowerCase() == 'false' ? false : true }),
+                'eq-null': () => ({ $eq: null }),
+                'neq-null': () => ({ $ne: null }),
+                'eq-oid': () => ({ $eq: Types.ObjectId.isValid(value) ? new Types.ObjectId(value) : value }),
+                'neq-oid': () => ({ $ne: Types.ObjectId.isValid(value) ? new Types.ObjectId(value) : value }),
             };
-            const fn = map[expression || 'eq-string'];
+            const fn = map[expression || 'eq'];
             if (!fn)
                 return p;
             return {

package/build/src/MongooseDatasource.d.ts

@@ -1,11 +1,13 @@
 import { RouteOptions } from "./RouteOptions.js";
-import { LivequeryRequest, LivequeryBaseEntity } from '@livequery/types';
+import { LivequeryRequest, WebsocketSyncPayload } from '@livequery/types';
 import mongoose, { Connection } from 'mongoose';
+import { Subject } from 'rxjs/internal/Subject';
 export type LivequeryDatasource<T> = {
     query(query: LivequeryRequest, options: T, connection: any): any;
 };
-export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions> {
+export declare class MongooseDatasource extends Subject<WebsocketSyncPayload<any>> implements LivequeryDatasource<RouteOptions> {
     #private;
+    readonly refs: Map<string, Set<string>>;
     query(_: LivequeryRequest, config: RouteOptions, connection: Connection): Promise<mongoose.mongo.DeleteResult | mongoose.UpdateWriteOpResult | {
         items: any[];
         summary: any;
@@ -30,15 +32,5 @@ export declare class MongooseDatasource implements LivequeryDatasource<RouteOpti
     } | {
         item: any;
     }>;
-    normalizeRef(req: LivequeryRequest, schema: mongoose.Schema): Promise<LivequeryRequest | {
-        keys: any;
-        body: any;
-        ref: string;
-        is_collection: boolean;
-        collection_ref: string;
-        schema_collection_ref: string;
-        doc_id?: string;
-        options: import("@livequery/types").QueryOption<LivequeryBaseEntity>;
-        method?: string;
-    }>;
+    normalizeRef(req: LivequeryRequest, schema: mongoose.Schema): Promise<LivequeryRequest>;
 }

package/build/src/MongooseDatasource.js

@@ -3,19 +3,23 @@ import { MongoQuery } from "./MongoQuery.js";
 import mongoose from 'mongoose';
 import { ObjectId } from 'bson';
 import { SmartCache } from './SmartCache.js';
-export class MongooseDatasource {
+import { Subject } from 'rxjs/internal/Subject';
+export class MongooseDatasource extends Subject {
     #schemas = new SmartCache();
     #models = new SmartCache();
+    refs = new Map();
     async query(_, config, connection) {
         const db = typeof config.db == 'function' ? await config.db(_) : config.db || process.env.DB_NAME || 'main';
         const schema = config.schema;
         const collection_name = schema.options.collection;
-        const model = await this.#models.get(`${db}::${collection_name}`, async () => {
+        const model = await this.#models.get(`${db}|${collection_name}`, async () => {
             return connection.model(collection_name, schema, collection_name);
         });
         const query = await this.normalizeRef(_, schema);
-        if (query.method == 'get')
+        if (query.method == 'get') {
+            config.realtime && this.#log(query, model);
             return await this.#get(query, model);
+        }
         if (query.method == 'post')
             return this.#post(query, model);
         if (query.method == 'put')
@@ -26,6 +30,12 @@ export class MongooseDatasource {
             return this.#del(query, model);
         throw { status: 500, code: 'INVAILD_METHOD', message: 'Invaild method' };
     }
+    #log(req, model) {
+        const _ = this.refs.get(model.collection.name);
+        const set = _ || new Set();
+        set.add(req.collection_ref);
+        !_ && this.refs.set(model.collection.name, set);
+    }
     async #get(req, model) {
         const { limit, items, count, has, summary } = await MongoQuery.query(req, model);
         const current = items.length;
@@ -145,15 +155,15 @@ export class MongooseDatasource {
     async normalizeRef(req, schema) {
         const fields = await this.#schemas.get(schema, async () => {
             return new Set(Object.entries(schema.paths).filter(([k, v]) => {
-                return v.instance == 'ObjectID';
+                return (v.instance == 'Array' ? v.getEmbeddedSchemaType().instance : v.instance) == 'ObjectID';
             }).map(([k, v]) => k));
         });
         if (fields.size == 0)
             return req;
         return {
             ...req,
-            keys: this.#convert(req.keys, fields),
-            body: this.#convert(req.body, fields)
+            ...req.keys ? { keys: this.#convert(req.keys, fields) } : {},
+            ...req.body ? { body: this.#convert(req.body, fields) } : {}
         };
     }
 }

package/build/src/RouteOptions.d.ts

@@ -4,5 +4,4 @@ export type RouteOptions<T = any> = {
     realtime?: boolean;
     schema: Schema<T>;
     db?: string | ((req: LivequeryRequest) => Promise<string> | string);
-    object_ids_fields: string[];
 };

package/package.json

@@ -6,7 +6,7 @@
     "repository": {
         "url": "git@github.com:livequery/mongoose.git"
     },
-    "version": "2.0.47",
+    "version": "2.0.50",
     "description": "Mongoose datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",