@livequery/client 1.0.52 → 1.0.80

package/build/Collection.d.ts

@@ -28,7 +28,9 @@ export declare class CollectionObservable<T extends LivequeryBaseEntity = Livequ
     private ref;
     private collection_options;
     readonly $changes: Subject<UpdatedData<T>>;
-    constructor(ref: string, collection_options: CollectionOption<T>);
+    value: CollectionStream<T>;
+    $: Subject<CollectionStream<T>>;
+    constructor(ref: string | false | null | '' | undefined, collection_options: CollectionOption<T>);
     set_realtime(realtime: boolean): void;
     private sync;
     private fetch_data;
@@ -43,6 +45,6 @@ export declare class CollectionObservable<T extends LivequeryBaseEntity = Livequ
     }>;
     update({ id: update_payload_id, ...payload }: Partial<T>): Promise<any>;
     remove(remove_document_id?: string): Promise<void>;
-    trigger<T>(name: string, payload?: object, trigger_document_id?: string): Promise<T>;
+    trigger<T>(name: string, payload?: object, trigger_document_id?: string): Promise<T | undefined>;
 }
 export {};

package/build/Collection.js

@@ -1,30 +1,35 @@
 import { Subject, Observable, merge } from 'rxjs';
-import { get_sort_function } from './helpers/get_sort_function.js';
 import { bufferTime, filter, map } from 'rxjs/operators';
 export class CollectionObservable extends Observable {
     ref;
     collection_options;
     $changes = new Subject();
-    #$state = new Subject();
-    #subscriptions = new Set();
-    #state;
+    #queries = new Set();
     #next_cursor = {};
     #IdMap = new Map();
     #refs = [];
+    value = {
+        has_more: false,
+        items: [],
+        options: {},
+        loading: false
+    };
+    $ = new Subject();
     constructor(ref, collection_options) {
         super(o => {
-            this.#state = { items: [], options: collection_options.filters, has_more: false };
-            const subscription = this.#$state.subscribe(o);
+            const subscription = this.$.subscribe(o);
             const auto_reload_interval = collection_options.reload_interval && setInterval(() => this.reload(), collection_options.reload_interval);
             return () => {
-                this.#subscriptions.forEach(s => s.unsubscribe());
                 subscription.unsubscribe();
+                this.#queries.forEach(s => s.unsubscribe());
                 clearInterval(auto_reload_interval);
             };
         });
         this.ref = ref;
         this.collection_options = collection_options;
-        if (ref.startsWith('/') || ref.endsWith('/'))
+        if (collection_options.filters)
+            this.value.options = collection_options.filters;
+        if (ref && (ref.startsWith('/') || ref.endsWith('/')))
             throw 'INVAILD_REF_FORMAT';
         this.#refs = this.#ref_parser(ref);
     }
@@ -50,13 +55,13 @@ export class CollectionObservable extends Observable {
         for (const { data, error, ref } of stream) {
             // Error & paging
             if (error) {
-                this.#state.error = error;
+                this.value.error = error;
                 actions.update = true;
             }
             if (data?.paging?.n == 0) {
                 this.#next_cursor[ref] = data?.paging?.next_cursor;
-                this.#state.has_more = Object.values(this.#next_cursor).some(v => v && v != '#');
-                this.#state.loading = false;
+                this.value.has_more = Object.values(this.#next_cursor).some(v => v && v != '#');
+                this.value.loading = false;
                 actions.update = true;
             }
             // Sync 
@@ -73,40 +78,34 @@ export class CollectionObservable extends Observable {
                         || (
                         // Is realtime update that match filters
                         (realtime || from_local) && Object
-                            .keys(this.#state.options || {})
+                            .keys(this.value.options || {})
                             .filter(key => !key.includes('_'))
                             .every(key => {
                             try {
                                 const [field, expression] = key.split(':');
                                 const a = payload[field];
-                                const b = this.#state.options?.[field];
+                                const b = this.value.options?.[field];
                                 if (!expression)
                                     return a == b;
                                 if (expression == 'ne')
                                     return a != b;
                                 if (expression == 'lt')
-                                    return a < b;
+                                    return typeof a == 'number' && typeof b == 'number' && a < b;
                                 if (expression == 'lte')
-                                    return a <= b;
+                                    return typeof a == 'number' && typeof b == 'number' && a <= b;
                                 if (expression == 'gt')
-                                    return a > b;
+                                    return typeof a == 'number' && typeof b == 'number' && a > b;
                                 if (expression == 'gte')
-                                    return a >= b;
-                                if (expression == 'in-array')
-                                    return a?.includes(b);
-                                if (expression == 'contains')
-                                    return a?.some(e => b?.includes(e));
-                                if (expression == 'not-contains')
-                                    return a?.every(e => !b?.includes(e));
+                                    return typeof a == 'number' && typeof b == 'number' && a >= b;
+                                if (expression == 'in' || expression == 'like')
+                                    return Array.isArray(a) && a?.includes(b);
                                 if (expression == 'between')
                                     return (b[0] <= a && a <= b[1]);
-                                if (expression == 'like')
-                                    return a.includes(b);
                             }
                             catch (e) { }
                             return false;
                         }))) {
-                        this.#state.items.push({
+                        this.value.items.push({
                             ...payload,
                             __adding: false,
                             __updating: false,
@@ -126,8 +125,8 @@ export class CollectionObservable extends Observable {
                         if (Object.keys(payload).some(key => ['created_at', this.collection_options?.filters?._order_by].includes(key))) {
                             actions.reindex = true;
                         }
-                        this.#state.items[index] = {
-                            ...this.#state.items[index],
+                        this.value.items[index] = {
+                            ...this.value.items[index],
                             __adding: false,
                             __updating: false,
                             __removing: false,
@@ -137,7 +136,7 @@ export class CollectionObservable extends Observable {
                     if (type == 'removed') {
                         actions.reindex = true;
                         actions.update = true;
-                        this.#state.items.splice(index, 1);
+                        this.value.items.splice(index, 1);
                         for (const [document_id, i] of this.#IdMap) {
                             i == index && this.#IdMap.delete(document_id);
                             i > index && this.#IdMap.set(document_id, i - 1);
@@ -147,33 +146,44 @@ export class CollectionObservable extends Observable {
             }
         }
         if (actions.reindex) {
-            this.#state.items = this.#state.items.sort(get_sort_function(this.#state.items[0], this.collection_options?.filters?._order_by || 'created_at', this.collection_options?.filters?._sort));
+            const _sort = this.collection_options?.filters?._sort || 'desc';
+            const _order_by = this.collection_options?.filters?._order_by || 'created_at';
+            this.value.items = this.value.items.sort((a, b) => {
+                const ka = a[_order_by];
+                const kb = b[_order_by];
+                if (typeof ka == 'string' && typeof kb == 'string')
+                    return ka.localeCompare(ka) * (_sort == 'desc' ? -1 : 1);
+                if ((typeof ka == 'number' || typeof ka == 'number')
+                    && (typeof kb == 'number' || typeof kb == 'number'))
+                    return (ka - kb) * (_sort == 'desc' ? -1 : 1);
+                return 1;
+            });
             this.#IdMap.clear();
-            this.#state.items.map((item, index) => this.#IdMap.set(item.id, index));
+            this.value.items.map((item, index) => this.#IdMap.set(item.id, index));
         }
-        actions.update && this.#$state.next(this.#state);
+        actions.update && this.$.next(this.value);
     }
     fetch_data(options = {}, flush = false) {
         if (this.#refs.length == 0)
             return;
         if (flush) {
             this.#next_cursor = {};
-            this.#subscriptions.forEach(s => s.unsubscribe());
-            this.#subscriptions.clear();
+            this.#queries.forEach(s => s.unsubscribe());
+            this.#queries.clear();
             this.#IdMap.clear();
         }
         const has_more_data_refs = this.#refs.filter(ref => this.#next_cursor[ref] === undefined || (this.#next_cursor[ref] && this.#next_cursor[ref] != '#'));
         // Load more but no more data || loading 
-        if (!flush && (has_more_data_refs.length == 0 || this.#state.loading))
+        if (!flush && (has_more_data_refs.length == 0 || this.value.loading))
             return;
-        this.#state = {
-            ...this.#state,
-            items: flush ? [] : this.#state.items,
-            error: null,
+        this.value = {
+            ...this.value,
+            items: flush ? [] : this.value.items,
+            error: undefined,
             loading: true,
             options
         };
-        this.#$state.next(this.#state);
+        this.$.next(this.value);
         const queries = has_more_data_refs.map(ref => (this
             .collection_options
             .transporter
@@ -181,37 +191,41 @@ export class CollectionObservable extends Observable {
         const reload = () => queries.map(q => q.reload());
         const $ = merge(...queries.map((q, index) => q.pipe(map(data => ({ ...data, ref: has_more_data_refs[index] }))))).pipe(bufferTime(500), filter(list => list.length > 0), map(data => this.sync(data)));
         const subscription = Object.assign($.subscribe(), { reload });
-        this.#subscriptions.add(subscription);
+        this.#queries.add(subscription);
     }
     reload() {
-        this.#subscriptions.forEach(s => s.reload());
+        this.#queries.forEach(s => s.reload());
     }
     reset() {
         this.fetch_data({}, true);
     }
     fetch_more() {
-        this.fetch_data(this.#state?.options);
+        this.fetch_data(this.value?.options);
     }
     filter(filters) {
         this.fetch_data(filters, true);
     }
-    async add(payload) {
-        if (this.ref.includes('.'))
-            throw 'INVAILD_COLLECTION_REF_FOR_ADDING';
-        return await this.collection_options.transporter.add(`${this.ref}`, payload);
-    }
     #find_ref_by_id(id) {
-        if (!id)
+        if (!id || !this.ref)
             return { ref: this.ref, collection_ref: this.ref };
-        const ref = this.#state.items[this.#IdMap.get(id)].__ref;
-        if (!ref)
+        const index = this.#IdMap.get(id);
+        if (index == undefined)
+            return {};
+        const origin_ref = this.value.items[index].__ref;
+        if (!origin_ref)
             throw 'COLLECTION_REF_NOT_FOUND';
-        const refs = ref.split('/');
+        const refs = origin_ref.split('/');
         const collection_ref = refs.slice(0, refs.length - (refs.length % 2 == 1 ? 0 : 1)).join('/');
-        return { ref, id, collection_ref };
+        const ref = `${collection_ref}/${id}`;
+        return { ref, id, collection_ref, index };
+    }
+    async add(payload) {
+        return await this.collection_options.transporter.add(`${this.ref}`, payload);
     }
     async update({ id: update_payload_id, ...payload }) {
         const { id, ref } = this.#find_ref_by_id(update_payload_id);
+        if (!ref)
+            return;
         // Trigger local update
         this.sync([{
                 ref,
@@ -242,6 +256,8 @@ export class CollectionObservable extends Observable {
     }
     async remove(remove_document_id) {
         const { id, ref } = this.#find_ref_by_id(remove_document_id);
+        if (!ref)
+            return;
         this.sync([{
                 ref,
                 data: {
@@ -272,6 +288,8 @@ export class CollectionObservable extends Observable {
     }
     async trigger(name, payload, trigger_document_id) {
         const { ref } = this.#find_ref_by_id(trigger_document_id);
+        if (!ref)
+            return;
         return await this.collection_options.transporter.trigger(ref, name, {}, payload);
     }
 }

package/package.json

@@ -4,7 +4,7 @@
   "repository": {
     "url": "https://github.com/livequery/client"
   },
-  "version": "1.0.52",
+  "version": "1.0.80",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/helpers/get_sort_function.d.ts

@@ -1 +0,0 @@
-export declare function get_sort_function(data: any, key: string, order?: 'asc' | 'desc'): (a: any, b: any) => number;

package/build/helpers/get_sort_function.js

@@ -1,16 +0,0 @@
-export function get_sort_function(data, key, order = 'desc') {
-    const type = typeof data?.[key];
-    if (type == 'bigint' || type == 'number') {
-        if (order == 'asc')
-            return (a, b) => a[key] - b[key] || ((a.created_at || 1) - (b.created_at || 0));
-        if (order == 'desc')
-            return (a, b) => b[key] - a[key] || ((a.created_at || 1) - (b.created_at || 0));
-    }
-    if (type == 'string') {
-        if (order == 'asc')
-            return (a, b) => a[key].localeCompare(b[key]) || ((a.created_at || 1) - (b.created_at || 0));
-        if (order == 'desc')
-            return (a, b) => b[key].localeCompare(a[key]) || ((a.created_at || 1) - (b.created_at || 0));
-    }
-    return () => 1;
-}