@webda/core 1.6.0-beta.3 → 2.0.0-beta.0

package/lib/stores/store.d.ts

@@ -3,6 +3,7 @@ import { ConfigurationProvider } from "../index";
 import { CoreModel, CoreModelDefinition } from "../models/coremodel";
 import { Service, ServiceParameters } from "../services/service";
 import { Context } from "../utils/context";
+import { WebdaQL } from "./webdaql/query";
 export declare class StoreNotFoundError extends WebdaError {
     constructor(uuid: string, storeName: string);
 }
@@ -163,32 +164,32 @@ export interface EventStorePartialUpdated {
 /**
  * Event sent when a query on the store is emitted
  */
-export interface EventStoreFind {
+export interface EventStoreQuery {
     /**
      * Request sent
      */
-    request: any;
+    query: string;
     /**
      * Emitting store
      */
     store: Store;
     /**
-     * Offset on the results
+     * The parsed query by our grammar
      */
-    offset: number;
-    /**
-     * Max number of results
-     */
-    limit: number;
+    parsedQuery: WebdaQL.Query;
 }
 /**
  * Event sent when query is resolved
  */
-export interface EventStoreFound extends EventStoreFind {
+export interface EventStoreQueried extends EventStoreQuery {
     /**
      * Results from the query
      */
     results: CoreModel[];
+    /**
+     * The next continuation token
+     */
+    continuationToken: string;
 }
 /**
  * Event sent when object is created via POST request
@@ -296,8 +297,38 @@ export declare type ExposeParameters = {
          * Do not expose the DELETE
          */
         delete?: boolean;
+        /**
+         * Do not expose the query endpoint
+         */
+        query?: boolean;
     };
+    /**
+     * For confidentiality sometimes you might prefer to expose query through PUT
+     * To avoid GET logging
+     */
+    queryMethod: "PUT" | "GET";
 };
+/**
+ * Represent a query result on the Store
+ */
+export interface StoreFindResult<T> {
+    /**
+     * Current result objects
+     */
+    results: T[];
+    /**
+     * Continuation Token if more results are available
+     */
+    continuationToken?: string;
+    /**
+     * Remaining filtering to do as current store cannot filter
+     *
+     * If `true`, no more filtering is required apart from permissions
+     * If `filter === undefined`, a full postquery filtering will happen
+     * Otherwise filter.eval while be used on every results
+     */
+    filter?: WebdaQL.Expression | true;
+}
 /**
  * Store parameter
  */
@@ -315,16 +346,42 @@ export declare class StoreParameters extends ServiceParameters {
     /**
      * Expose the service to an urls
      */
-    expose?: ExposeParameters | boolean | string;
+    expose?: ExposeParameters;
     /**
      * Allow to load object that does not have the type data
      *
-     * @deprecated 2.0
      * @default true
      */
     strict?: boolean;
+    /**
+     * Slow query threshold
+     *
+     * @default 30000
+     */
+    slowQueryThreshold: number;
     constructor(params: any, service: Service<any>);
 }
+export declare type StoreEvents = {
+    "Store.PartialUpdated": EventStorePartialUpdated;
+    "Store.Save": EventStoreSave;
+    "Store.Saved": EventStoreSaved;
+    "Store.PatchUpdate": EventStorePatchUpdate;
+    "Store.PatchUpdated": EventStorePatchUpdated;
+    "Store.Update": EventStoreUpdate;
+    "Store.Updated": EventStoreUpdated;
+    "Store.Delete": EventStoreDelete;
+    "Store.Deleted": EventStoreDeleted;
+    "Store.Get": EventStoreGet;
+    "Store.Query": EventStoreQuery;
+    "Store.Queried": EventStoreQueried;
+    "Store.WebCreate": EventStoreWebCreate;
+    "Store.Action": EventStoreAction;
+    "Store.Actioned": EventStoreActioned;
+    "Store.WebUpdate": EventStoreWebUpdate;
+    "Store.WebGetNotFound": EventStoreWebGetNotFound;
+    "Store.WebGet": EventStoreWebGet;
+    "Store.WebDelete": EventStoreWebDelete;
+};
 /**
  * A mapping service allow to link two object together
  *
@@ -367,7 +424,11 @@ export interface MappingService<T = any> {
  *   }
  * @category CoreServices
  */
-declare abstract class Store<T extends CoreModel = CoreModel, K extends StoreParameters = StoreParameters> extends Service<K> implements ConfigurationProvider, MappingService<T> {
+declare abstract class Store<T extends CoreModel = CoreModel, K extends StoreParameters = StoreParameters, E extends StoreEvents = StoreEvents> extends Service<K, E> implements ConfigurationProvider, MappingService<T> {
+    /**
+     * Cache store
+     */
+    _cacheStore: Store<T>;
     /**
      * Contain the reverse map
      */
@@ -391,6 +452,23 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * Contain the model uuid field
      */
     protected _uuidField: string;
+    /**
+     * Add metrics counter
+     */
+    metrics: {
+        save: number;
+        update: number;
+        partialUpdate: number;
+        get: number;
+        increment: number;
+        delete: number;
+        collectionUpsert: number;
+        collectionDelete: number;
+        attributeDelete: number;
+        query: number;
+        queryDuration: number;
+        slowQueries: number;
+    };
     /**
      * Load the parameters for a service
      */
@@ -401,17 +479,35 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * @throws Error if model is not found
      */
     computeParameters(): void;
+    logSlowQuery(query: string, reason: string, time: number): void;
     /**
      * Return Store current model
      * @returns
      */
     getModel(): CoreModelDefinition;
     getLastUpdateField(): string;
-    getObject(uid: string): Promise<CoreModel>;
+    /**
+     * Get From Cache or main
+     * @param uid
+     * @param raiseIfNotFound
+     * @returns
+     */
+    _getFromCache(uid: string, raiseIfNotFound?: boolean): Promise<T>;
+    /**
+     * Get object from store
+     * @param uid
+     * @returns
+     */
+    getObject(uid: string): Promise<T>;
     /**
      * @inheritdoc
      */
     initRoutes(): void;
+    /**
+     * OVerwrite the model
+     * Used mainly in test
+     */
+    setModel(model: CoreModelDefinition): void;
     /**
      * Get the url where the store is exposed
      */
@@ -433,9 +529,22 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * @param store
      */
     addReverseMap(prop: string, store: MappingService): void;
-    incrementAttribute(uid: string, prop: string, value: number): any;
+    incrementAttribute(uid: string, prop: string, value: number): Promise<void | any[]>;
     upsertItemToCollection(uid: string, prop: string, item: any, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<void>;
     deleteItemFromCollection(uid: string, prop: string, index: number, itemWriteCondition: any, itemWriteConditionField?: string): Promise<void>;
+    /**
+     * Query store with WebdaQL
+     * @param query
+     * @param context to apply permission
+     */
+    query(query: string, context?: Context): Promise<{
+        results: T[];
+        continuationToken?: string;
+    }>;
+    /**
+     * Expose query to http
+     */
+    protected httpQuery(ctx: Context): Promise<void>;
     /**
      * Save an object
      *
@@ -504,7 +613,7 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * @param uuid
      * @returns
      */
-    cascadeDelete(obj: CoreModel, uuid: string): Promise<any>;
+    cascadeDelete(obj: CoreModel, _uuid: string): Promise<any>;
     /**
      * Delete an object from the store without condition nor async
      * @param uid to delete
@@ -525,7 +634,7 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * @param id
      * @param callback
      */
-    canTriggerConfiguration(id: string, callback: () => void): boolean;
+    canTriggerConfiguration(_id: string, _callback: () => void): boolean;
     /**
      * Provide a way to store configuration in store
      * @param {string} id
@@ -553,16 +662,9 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      */
     setAttribute(uid: string, property: string, value: any): Promise<void>;
     /**
-     * Search inside the store
-     *
-     * Still need to define a good abstraction for it
-     *
-     * @param request
-     * @param offset
-     * @param limit
-     * @returns
+     * @override
      */
-    find(request?: any, offset?: number, limit?: number): Promise<any>;
+    protected simulateFind(query: WebdaQL.Query, uuids: string[]): Promise<StoreFindResult<T>>;
     /**
      * Handle POST
      * @param ctx
@@ -601,7 +703,10 @@ declare abstract class Store<T extends CoreModel = CoreModel, K extends StorePar
      * Return the model uuid field
      */
     getUuidField(): string;
-    abstract _find(request: any, offset: any, limit: any): Promise<CoreModel[]>;
+    /**
+     * Search within the store
+     */
+    abstract find(query: WebdaQL.Query): Promise<StoreFindResult<T>>;
     /**
      * Check if an object exists
      * @abstract