@webda/core 3.6.0 → 3.8.0

package/lib/models/coremodel.d.ts

@@ -1,8 +1,10 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
 import { JSONSchema7 } from "json-schema";
 import { ModelGraph, ModelsTree } from "../application.js";
 import { Core } from "../core.js";
 import { Service } from "../services/service.js";
-import { Store } from "../stores/store.js";
+import { Store, StoreEvents } from "../stores/store.js";
 import { OperationContext } from "../utils/context.js";
 import { HttpMethodType } from "../utils/httpcontext.js";
 import { ModelActions, RawModel } from "./relations.js";
@@ -15,10 +17,18 @@ import { ModelActions, RawModel } from "./relations.js";
  * @returns
  */
 export declare function Expose(params?: Partial<ExposeParameters>): (target: CoreModelDefinition) => void;
+/**
+ * Attribute of an object
+ *
+ * Filter out methods
+ */
+export type Attributes<T extends object> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
 /**
  * Filter type keys by type
  */
-export type FilterKeys<T extends CoreModel, K> = {
+export type FilterAttributes<T extends CoreModel, K> = {
     [L in keyof T]: T[L] extends K ? L : never;
 }[keyof T];
 /**
@@ -107,7 +117,7 @@ export interface CoreModelDefinition<T extends CoreModel = CoreModel> {
      * @param object to load data from
      * @param context if the data is unsafe from http
      */
-    factory(model: new () => T, object: any, context?: OperationContext): T;
+    factory<T extends CoreModel>(this: Constructor<T>, object: Partial<T>, context?: OperationContext): T;
     /**
      * Get the model actions
      */
@@ -172,10 +182,17 @@ export interface CoreModelDefinition<T extends CoreModel = CoreModel> {
         results: T[];
         continuationToken?: string;
     }>;
+    on<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any, async?: boolean): void;
+    onAsync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any): any;
+    emit<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): any;
+    emitSync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): Promise<void>;
 }
 export type Constructor<T, K extends Array<any> = []> = new (...args: K) => T;
 /**
  * Make a property hidden from json
+ *
+ * This property will not be saved in the store
+ *
  * @param target
  * @param propertyKey
  */
@@ -200,18 +217,18 @@ export declare class ModelRef<T extends CoreModel> {
     toString(): string;
     toJSON(): string;
     getUuid(): string;
-    deleteItemFromCollection(prop: FilterKeys<T, any[]>, index: number, itemWriteCondition: any, itemWriteConditionField?: string): Promise<void>;
-    upsertItemToCollection(prop: FilterKeys<T, any[]>, item: any, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<void>;
+    deleteItemFromCollection(prop: FilterAttributes<T, any[]>, index: number, itemWriteCondition: any, itemWriteConditionField?: string): Promise<this>;
+    upsertItemToCollection(prop: FilterAttributes<T, any[]>, item: any, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<this>;
     exists(): Promise<boolean>;
     delete(): Promise<void>;
     conditionalPatch(updates: Partial<T>, conditionField: any, condition: any): Promise<boolean>;
     patch(updates: Partial<T>): Promise<boolean>;
-    setAttribute(attribute: keyof T, value: any): Promise<void>;
-    removeAttribute(attribute: keyof T, itemWriteCondition?: any, itemWriteConditionField?: keyof T): Promise<void>;
+    setAttribute(attribute: keyof T, value: any): Promise<this>;
+    removeAttribute(attribute: keyof T, itemWriteCondition?: any, itemWriteConditionField?: keyof T): Promise<this>;
     incrementAttributes(info: {
-        property: FilterKeys<T, number>;
+        property: FilterAttributes<T, number>;
         value: number;
-    }[]): Promise<any[]>;
+    }[]): Promise<this>;
 }
 export declare class ModelRefWithCreate<T extends CoreModel> extends ModelRef<T> {
     /**
@@ -240,6 +257,7 @@ export declare class ModelRefCustom<T extends CoreModel> extends ModelRef<T> {
     getUuid(): string;
 }
 export type ModelRefCustomProperties<T extends CoreModel, K> = ModelRefCustom<T> & K;
+export declare const Emitters: WeakMap<Constructor<CoreModel>, EventEmitter>;
 /**
  * Basic Object in Webda
  *
@@ -254,7 +272,7 @@ declare class CoreModel {
     /**
      * Class reference to the object
      */
-    __class: CoreModelDefinition;
+    __class: CoreModelDefinition<this>;
     /**
      * Type name
      */
@@ -291,6 +309,33 @@ declare class CoreModel {
      */
     __deleted: boolean;
     constructor();
+    /**
+     * Listen to events on the model
+     * @param event
+     * @param listener
+     * @param async
+     */
+    static on<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, listener: (evt: StoreEvents[Key]) => any, async?: boolean): void;
+    /**
+     * Emit an event for this class
+     * @param this
+     * @param event
+     * @param evt
+     */
+    static emit<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): void;
+    /**
+     * Emit an event for this class and wait for all listeners to finish
+     * @param this
+     * @param event
+     * @param evt
+     */
+    static emitSync<T extends CoreModel, Key extends keyof StoreEvents>(this: Constructor<T>, event: Key, evt: StoreEvents[Key]): Promise<void>;
+    /**
+     * Listen to events on the model asynchronously
+     * @param event
+     * @param listener
+     */
+    static onAsync<Key extends keyof StoreEvents>(event: Key, listener: (evt: StoreEvents[Key]) => any): void;
     /**
      *
      * @returns
@@ -383,6 +428,22 @@ declare class CoreModel {
      * @param prefix
      */
     static flat(target: any, data: any, split?: string, prefix?: string): any;
+    /**
+     * Complete the query with __type/__types
+     * @param query
+     * @param includeSubclass
+     * @returns
+     */
+    protected static completeQuery(query: string, includeSubclass?: boolean): string;
+    /**
+     * Iterate through the model
+     * @param this
+     * @param query
+     * @param includeSubclass
+     * @param context
+     * @returns
+     */
+    static iterate<T extends CoreModel>(this: Constructor<T>, query?: string, includeSubclass?: boolean, context?: OperationContext): AsyncGenerator<T>;
     /**
      * Query for models
      * @param this
@@ -444,7 +505,7 @@ declare class CoreModel {
      * Create an object
      * @returns
      */
-    static factory(model: new () => CoreModel, object: any, context?: OperationContext): CoreModel;
+    static factory<T extends CoreModel>(this: Constructor<T>, object: Partial<T>, context?: OperationContext): T;
     /**
      * Detect what looks like a CoreModel but can be from different version
      * @param object
@@ -485,7 +546,7 @@ declare class CoreModel {
      * @param raw data
      * @param secure if false will ignore any _ variable
      */
-    load(raw: RawModel<this>, secure?: boolean): this;
+    load(raw: RawModel<this>, secure?: boolean, relations?: boolean): this;
     /**
      * Patch every attribute that is based on a relation
      * to add all the helpers
@@ -608,6 +669,36 @@ declare class CoreModel {
      * Called when object is updated
      */
     _onUpdated(): Promise<void>;
+    /**
+     * Set attribute on the object and database
+     * @param property
+     * @param value
+     */
+    setAttribute(property: keyof this, value: any): Promise<void>;
+    /**
+     * Remove attribute from both the object and db
+     * @param property
+     */
+    removeAttribute(property: keyof this): Promise<void>;
+    /**
+     * Increment an attribute both in store and object
+     * @param property
+     * @param value
+     */
+    incrementAttribute(property: FilterAttributes<this, number>, value: number): Promise<void>;
+    /**
+     * Return a model ref
+     * @returns
+     */
+    getRef<T extends this>(): ModelRef<T>;
+    /**
+     * Increment a attributes both in store and object
+     * @param info
+     */
+    incrementAttributes(info: {
+        property: string;
+        value: number;
+    }[]): Promise<void>;
 }
 /**
  * CoreModel with a uuid

package/lib/models/coremodel.js

@@ -4,9 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { EventEmitter } from "events";
 import util from "util";
 import { v4 as uuidv4 } from "uuid";
-import { Core } from "../core.js";
+import { Core, EventEmitterUtils } from "../core.js";
 import { WebdaError } from "../errors.js";
 import { BinariesImpl, Binary } from "../services/binary.js";
 import { Throttler } from "../utils/throttler.js";
@@ -68,23 +69,29 @@ class CoreModelQuery {
     async forEach(callback, query, context, parallelism = 3) {
         const throttler = new Throttler();
         throttler.setConcurrency(parallelism);
-        let continuationToken;
-        do {
-            const result = await this.query(query + continuationToken ? "OFFSET " + continuationToken : "", context);
-            continuationToken = result.continuationToken;
-            for (const model of result.results) {
-                throttler.queue(() => callback(model));
-            }
-            await throttler.waitForCompletion();
-        } while (continuationToken);
+        for await (const model of this.iterate(query, context)) {
+            throttler.execute(() => callback(model));
+        }
+        return throttler.wait();
     }
     /**
-     * Get all objects linked
+     * Iterate through all
      * @param context
      * @returns
      */
-    async getAll(query, context) {
-        return Core.get().getModelStore(this.getTargetModel()).queryAll(this.completeQuery(query), context);
+    iterate(query, context) {
+        return Core.get().getModelStore(this.getTargetModel()).iterate(this.completeQuery(query), context);
+    }
+    /**
+     * Get all the objects
+     * @returns
+     */
+    async getAll(context) {
+        let res = [];
+        for await (const item of this.iterate(this.completeQuery(), context)) {
+            res.push(item);
+        }
+        return res;
     }
 }
 __decorate([
@@ -101,6 +108,9 @@ __decorate([
 ], CoreModelQuery.prototype, "targetModel", void 0);
 /**
  * Make a property hidden from json
+ *
+ * This property will not be saved in the store
+ *
  * @param target
  * @param propertyKey
  */
@@ -151,6 +161,7 @@ export class ModelRef {
     }
     set(id) {
         this.uuid = id instanceof CoreModel ? id.getUuid() : id;
+        this.parent?.__dirty.add(Object.keys(this.parent).find(k => this.parent[k] === this));
     }
     toString() {
         return this.uuid;
@@ -161,11 +172,36 @@ export class ModelRef {
     getUuid() {
         return this.uuid;
     }
-    deleteItemFromCollection(prop, index, itemWriteCondition, itemWriteConditionField) {
-        return this.store.deleteItemFromCollection(this.uuid, prop, index, itemWriteCondition, itemWriteConditionField);
+    async deleteItemFromCollection(prop, index, itemWriteCondition, itemWriteConditionField) {
+        const updateDate = await this.store.deleteItemFromCollection(this.uuid, prop, index, itemWriteCondition, itemWriteConditionField);
+        await this.model.emitSync("Store.PartialUpdated", {
+            object_id: this.uuid,
+            store: this.store,
+            updateDate,
+            partial_update: {
+                deleteItem: {
+                    property: prop,
+                    index: index
+                }
+            }
+        });
+        return this;
     }
-    upsertItemToCollection(prop, item, index, itemWriteCondition, itemWriteConditionField) {
-        return this.store.upsertItemToCollection(this.uuid, prop, item, index, itemWriteCondition, itemWriteConditionField);
+    async upsertItemToCollection(prop, item, index, itemWriteCondition, itemWriteConditionField) {
+        const updateDate = await this.store.upsertItemToCollection(this.uuid, prop, item, index, itemWriteCondition, itemWriteConditionField);
+        await this.model.emitSync("Store.PartialUpdated", {
+            object_id: this.uuid,
+            store: this.store,
+            updateDate,
+            partial_update: {
+                addItem: {
+                    value: item,
+                    property: prop,
+                    index: index
+                }
+            }
+        });
+        return this;
     }
     exists() {
         return this.store.exists(this.uuid);
@@ -179,14 +215,32 @@ export class ModelRef {
     patch(updates) {
         return this.store.conditionalPatch(this.uuid, updates, null, undefined);
     }
-    setAttribute(attribute, value) {
-        return this.store.setAttribute(this.uuid, attribute, value);
+    async setAttribute(attribute, value) {
+        await this.store.setAttribute(this.uuid, attribute, value);
+        return this;
     }
-    removeAttribute(attribute, itemWriteCondition, itemWriteConditionField) {
-        return this.store.removeAttribute(this.uuid, attribute, itemWriteCondition, itemWriteConditionField);
+    async removeAttribute(attribute, itemWriteCondition, itemWriteConditionField) {
+        await this.store.removeAttribute(this.uuid, attribute, itemWriteCondition, itemWriteConditionField);
+        await this.model?.emitSync("Store.PartialUpdated", {
+            object_id: this.uuid,
+            store: this.store,
+            partial_update: {
+                deleteAttribute: attribute
+            }
+        });
+        return this;
     }
-    incrementAttributes(info) {
-        return this.store.incrementAttributes(this.uuid, info);
+    async incrementAttributes(info) {
+        const updateDate = await this.store.incrementAttributes(this.uuid, info);
+        await this.model.emitSync("Store.PartialUpdated", {
+            object_id: this.uuid,
+            store: this.store,
+            updateDate,
+            partial_update: {
+                increments: info
+            }
+        });
+        return this;
     }
 }
 __decorate([
@@ -239,6 +293,7 @@ export class ModelRefCustom extends ModelRef {
         return this.uuid;
     }
 }
+export const Emitters = new WeakMap();
 /**
  * Basic Object in Webda
  *
@@ -262,6 +317,78 @@ class CoreModel {
                 ?.getApplication()
                 .getShortId(Core.get()?.getApplication().getModelFromInstance(this));
     }
+    /**
+     * Listen to events on the model
+     * @param event
+     * @param listener
+     * @param async
+     */
+    static on(event, listener, async = false) {
+        if (!Emitters.has(this)) {
+            Emitters.set(this, new EventEmitter());
+        }
+        // TODO Manage async
+        if (async) {
+            Core.get()
+                .getService("AsyncEvents")
+                .bindAsyncListener(this, event, listener);
+        }
+        else {
+            Emitters.get(this).on(event, listener);
+        }
+    }
+    /**
+     * Emit an event for this class
+     * @param this
+     * @param event
+     * @param evt
+     */
+    static emit(event, evt) {
+        let clazz = this;
+        // @ts-ignore
+        while (clazz) {
+            // Emit for all parent class
+            if (Emitters.has(clazz)) {
+                EventEmitterUtils.emit(Emitters.get(clazz), event, evt);
+            }
+            // @ts-ignore
+            if (clazz === CoreModel) {
+                break;
+            }
+            clazz = Object.getPrototypeOf(clazz);
+        }
+    }
+    /**
+     * Emit an event for this class and wait for all listeners to finish
+     * @param this
+     * @param event
+     * @param evt
+     */
+    static async emitSync(event, evt) {
+        let clazz = this;
+        let p = [];
+        // @ts-ignore
+        while (clazz) {
+            // Emit for all parent class
+            if (Emitters.has(clazz)) {
+                p.push(EventEmitterUtils.emitSync(Emitters.get(clazz), event, evt));
+            }
+            // @ts-ignore
+            if (clazz === CoreModel) {
+                break;
+            }
+            clazz = Object.getPrototypeOf(clazz);
+        }
+        await Promise.all(p);
+    }
+    /**
+     * Listen to events on the model asynchronously
+     * @param event
+     * @param listener
+     */
+    static onAsync(event, listener) {
+        this.on(event, listener, true);
+    }
     /**
      *
      * @returns
@@ -407,12 +534,12 @@ class CoreModel {
         }
     }
     /**
-     * Query for models
-     * @param this
-     * @param id
+     * Complete the query with __type/__types
+     * @param query
+     * @param includeSubclass
      * @returns
      */
-    static async query(query = "", includeSubclass = true, context) {
+    static completeQuery(query, includeSubclass = true) {
         if (!query.includes("__type")) {
             if (query.trim() !== "") {
                 query = ` AND ${query}`;
@@ -426,8 +553,29 @@ class CoreModel {
                 query = `__type = "${name}"${query}`;
             }
         }
+        return query;
+    }
+    /**
+     * Iterate through the model
+     * @param this
+     * @param query
+     * @param includeSubclass
+     * @param context
+     * @returns
+     */
+    static iterate(query = "", includeSubclass = true, context) {
+        // @ts-ignore
+        return this.store().iterate(this.completeQuery(query, includeSubclass), context);
+    }
+    /**
+     * Query for models
+     * @param this
+     * @param id
+     * @returns
+     */
+    static async query(query = "", includeSubclass = true, context) {
         // @ts-ignore
-        return this.store().query(query, context);
+        return this.store().query(this.completeQuery(query, includeSubclass), context);
     }
     /**
      * Return a proxy to the object to detect if dirty
@@ -553,8 +701,8 @@ class CoreModel {
      * Create an object
      * @returns
      */
-    static factory(model, object, context) {
-        return new model().setContext(context).load(object, context === undefined);
+    static factory(object, context) {
+        return object instanceof this ? object : new this().setContext(context).load(object, context === undefined);
     }
     /**
      * Detect what looks like a CoreModel but can be from different version
@@ -614,7 +762,7 @@ class CoreModel {
      * @param raw data
      * @param secure if false will ignore any _ variable
      */
-    load(raw, secure = false) {
+    load(raw, secure = false, relations = true) {
         // Object assign with filter
         for (let prop in raw) {
             let val = raw[prop];
@@ -636,7 +784,9 @@ class CoreModel {
         if (!this.getUuid()) {
             this.setUuid(this.generateUid(raw));
         }
-        this.handleRelations();
+        if (relations) {
+            this.handleRelations();
+        }
         return this;
     }
     /**
@@ -740,7 +890,7 @@ class CoreModel {
      * @throws Error if the object is not coming from a store
      */
     async delete() {
-        return this.__store.delete(this.getUuid());
+        return this.__store.delete(this);
     }
     /**
      * Patch current object with this update
@@ -846,6 +996,9 @@ class CoreModel {
             if (value instanceof ModelRef) {
                 obj[i] = value.toString();
             }
+            else if (value instanceof Binary) {
+                obj[i] = value.toJSON();
+            }
             else {
                 obj[i] = value;
             }
@@ -904,6 +1057,50 @@ class CoreModel {
     async _onUpdated() {
         // Empty to be overriden
     }
+    /**
+     * Set attribute on the object and database
+     * @param property
+     * @param value
+     */
+    async setAttribute(property, value) {
+        await this.getRef().setAttribute(property, value);
+        this[property] = value;
+    }
+    /**
+     * Remove attribute from both the object and db
+     * @param property
+     */
+    async removeAttribute(property) {
+        await this.getRef().removeAttribute(property);
+        delete this[property];
+    }
+    /**
+     * Increment an attribute both in store and object
+     * @param property
+     * @param value
+     */
+    async incrementAttribute(property, value) {
+        return this.incrementAttributes([{ property, value }]);
+    }
+    /**
+     * Return a model ref
+     * @returns
+     */
+    getRef() {
+        return new ModelRef(this.getUuid(), this.__class);
+    }
+    /**
+     * Increment a attributes both in store and object
+     * @param info
+     */
+    async incrementAttributes(info) {
+        var _a;
+        await this.getRef().incrementAttributes(info);
+        for (let inc of info) {
+            this[_a = inc.property] ?? (this[_a] = 0);
+            this[inc.property] += inc.value;
+        }
+    }
 }
 __decorate([
     NotEnumerable