@olympeio/runtime-node 9.11.7 → 9.11.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olympeio/runtime-node",
-  "version": "9.11.7",
+  "version": "9.11.9",
   "description": "Olympe Node Runtime Environment",
   "types": "types/index.d.ts",
   "dependencies": {

package/types/data.d.ts

@@ -254,6 +254,16 @@ export abstract class CloudObject implements HasTag {
      */
     static exists(tag: InstanceOrTag): boolean;
 
+    /**
+     * Mark the specified instances as obsolete in cache database: the instances won't exist anymore in the local cache.
+     * It does not delete the instances from the remote data store and they can still be retrieved using a {@link Query}.
+     * Warning: this is only for experimented users: only use this method if you know what you are doing.
+     *
+     * @static
+     * @param {...InstanceOrTag} tags
+     */
+    static markObsolete(...tags: InstanceOrTag[]): void;
+
     /**
      * Create an instance of the specified data type (or `model`)
      * in the local datacloud (not persisted) with the specified property values.

package/types/other.d.ts

@@ -406,3 +406,67 @@ export class Process {
      */
     static isOnline(context: Context): Observable<boolean>;
 }
+
+export class EventMonitor {
+    /**
+     * Enable monitoring and start the periodic flush timer.
+     *
+     * Starts internal timers if they are not already running.
+     */
+    static enable(): void;
+
+    /**
+    * Disable monitoring and stop the periodic flush timer.
+    *
+    * Counters are preserved in memory until a flush or destroy.*/
+    static disable(): void;
+
+    /**
+     * Set how often the monitor flushes accumulated counts.
+     * Values lower than 1000ms are coerced to 1000ms.
+     *
+     * @param ms The flush frequency in milliseconds.
+     */
+    static setFlushFrequency(ms: number): void;
+
+    /**
+     * Set the HTTP destination (orchestrator) URL used when sending batches.
+     *
+     * @param url Destination URL.
+     */
+    static setDestinationUrl(url: string): void;
+
+    /**
+     * Track an occurrence of an event. No network call is made; an in-memory counter is incremented
+     * and later flushed in batch. If monitoring is disabled, the call is a no‑op.
+     *
+     * @param eventType One of {@link EventMonitor.EVENT_TYPE}.
+     * @param eventName Logical event name (e.g. brick name or endpoint id).
+     * @param options Additional context used for aggregation and payload (serviceAppName, host, olympeRuntimeId).
+     */
+    static track(
+        eventType: EventMonitor.EVENT_TYPE,
+        eventName: string,
+        options: { serviceAppName: string; host: string; olympeRuntimeId: string }
+    ): void;
+
+    /**
+     * Flush accumulated counts immediately. Resets counters after a successful send.
+     * If there is nothing to flush, resolves immediately.
+     */
+    static flush(): Promise<void>;
+
+    /**
+     * Stop timers and clear all in-memory counters.
+     */
+    static destroy(): void;
+}
+
+export namespace EventMonitor {
+    /** Event type enum */
+    export enum EVENT_TYPE {
+        REMOTE_ACTION = "Remote Action",
+        DATA_SOURCE = "Data Source",
+        ENDPOINT = "Endpoint"
+    }
+}

package/types/query.d.ts

@@ -281,6 +281,16 @@ export class Predicate {
      */
     static in(...tags: InstanceOrTag[]): Predicate;
 
+    /**
+     * Create a predicate matching a specified property to multiple values.
+     * **EXPERIMENTAL** this method and the in() method may change in the future.
+     * 
+     * @param property the property to use for filtering
+     * @param values the values that the property must match at least one
+     * @return new Predicate with the in operation
+     */
+    static propertyIn<T>(property: Property<T>, values: T[]): Predicate;
+
     /**
      * Create a predicate matching a specified property to a specified value.
      *