@webda/core 4.0.0-beta.2 → 4.0.0-beta.3

package/lib/stores/store.d.ts

@@ -1,115 +1,69 @@
-import { Counter, EventWithContext, Histogram } from "../core.js";
-import { ConfigurationProvider, WebdaError } from "../index.js";
-import { Constructor, CoreModel, CoreModelDefinition, FilterAttributes } from "../models/coremodel.js";
-import { Service, ServiceParameters } from "../services/service.js";
-import { OperationContext } from "../utils/context.js";
+import { Counter, Histogram } from "../metrics/metrics.js";
+import * as WebdaError from "../errors/errors.js";
+import { type Model, type ModelClass, type PrimaryKey, type Repository } from "@webda/models";
+import { ServiceParameters } from "../services/serviceparameters.js";
+import { Service } from "../services/service.js";
 import * as WebdaQL from "@webda/ql";
+import type { WebdaQLString } from "@webda/ql";
+import type { ModelMetadata } from "@webda/compiler";
+/** Error thrown when an item is not found in a store */
 export declare class StoreNotFoundError extends WebdaError.CodeError {
-    constructor(uuid: string, storeName: string);
+    /** Create a new StoreNotFoundError
+     * @param uuid - the item primary key
+     * @param storeName - the store name
+     */
+    constructor(uuid: PrimaryKey<any>, storeName: string);
 }
+/** Error thrown when a conditional update fails due to a version/condition mismatch */
 export declare class UpdateConditionFailError extends WebdaError.CodeError {
-    constructor(uuid: string, conditionField: string, condition: string | Date);
+    /** Create a new UpdateConditionFailError
+     * @param uuid - the item primary key
+     * @param conditionField - the condition field name
+     * @param condition - the expected condition value
+     */
+    constructor(uuid: PrimaryKey<any>, conditionField: string, condition: string | Date);
 }
 interface EventStore {
     /**
      * Target object
      */
-    object: CoreModel;
+    object: Model;
     /**
      * Object id
      */
-    object_id: string;
+    object_id: PrimaryKey<any>;
     /**
      * Store emitting
      */
     store: Store;
-    /**
-     * Context of the operation
-     */
-    context?: OperationContext;
 }
 /**
  * Event called before save of an object
  */
-export interface EventStoreSave extends EventStore {
-}
-/**
- * Event called after save of an object
- */
-export interface EventStoreSaved extends EventStoreSave {
-}
-/**
- * Event called before delete of an object
- */
-export interface EventStoreDelete extends EventStore {
+export interface EventStoreCreated extends EventStore {
 }
 /**
  * Event called after delete of an object
  */
-export interface EventStoreDeleted extends EventStoreDelete {
+export interface EventStoreDeleted extends EventStore {
 }
 /**
- * Event called on retrieval of an object
- */
-export interface EventStoreGet extends EventStore {
-}
-/**
- * Event called before action on an object
- */
-export interface EventStoreAction extends EventWithContext {
-    /**
-     * Name of the action
-     */
-    action: string;
-    /**
-     * Target object unless it is a global action
-     */
-    object?: CoreModel;
-    /**
-     * Model of the object if global action
-     */
-    model?: CoreModelDefinition;
-    /**
-     * Emitting store
-     */
-    store: Store;
-}
-/**
- * Event called after action on an object
- */
-export interface EventStoreActioned extends EventStoreAction {
-    /**
-     * Result of the action
-     */
-    result: any;
-}
-/**
- * Event called before update of an object
+ * Event called after update of an object
  */
-export interface EventStoreUpdate extends EventStore {
+export interface EventStoreUpdated extends EventStore {
     /**
      * Update content
      */
     update: any;
-}
-/**
- * Event called after update of an object
- */
-export interface EventStoreUpdated extends EventStoreUpdate {
     /**
      * Object uuid
      */
-    object_id: string;
+    object_id: PrimaryKey<any>;
     /**
      * Object before update
      */
     previous: any;
 }
-/**
- * Event called before patch update of an object
- */
-export interface EventStorePatchUpdate extends EventStoreUpdate {
-}
 /**
  * Event called after patch update of an object
  */
@@ -118,15 +72,15 @@ export interface EventStorePatchUpdated extends EventStoreUpdated {
 /**
  * Event called after partial update of an object
  */
-export interface EventStorePartialUpdated<T extends CoreModel = CoreModel> {
+export interface EventStorePartialUpdated<T extends Model = Model> {
     /**
      * Object uuid
      */
-    object_id: string;
+    object_id: PrimaryKey<any>;
     /**
      * Emitting store
      */
-    store: Store<T>;
+    store: Store<any>;
     /**
      * Update date
      */
@@ -185,123 +139,10 @@ export interface EventStorePartialUpdated<T extends CoreModel = CoreModel> {
         deleteAttribute?: string;
     };
 }
-/**
- * Event sent when a query on the store is emitted
- */
-export interface EventStoreQuery {
-    /**
-     * Request sent
-     */
-    query: string;
-    /**
-     * Emitting store
-     */
-    store: Store;
-    /**
-     * The parsed query by our grammar
-     */
-    parsedQuery: WebdaQL.Query;
-    /**
-     * Context in which the query was run
-     */
-    context: OperationContext;
-}
-/**
- * Event sent when query is resolved
- */
-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
- */
-export interface EventStoreWebCreate extends EventWithContext {
-    /**
-     * Properties for the object
-     */
-    values: any;
-    /**
-     * Target object
-     */
-    object: CoreModel;
-    /**
-     * Object id
-     */
-    object_id: string;
-    /**
-     * Emitting store
-     */
-    store: Store;
-}
-/**
- * Event sent when object is retrieved via GET request
- */
-export interface EventStoreWebGet extends EventWithContext {
-    /**
-     * Emitting store
-     */
-    store: Store;
-    /**
-     * Target object
-     */
-    object: CoreModel;
-}
-/**
- * Event sent when object is retrieved via GET request
- */
-export interface EventStoreWebGetNotFound extends EventWithContext {
-    /**
-     * Emitting store
-     */
-    store: Store;
-    /**
-     * Target object
-     */
-    uuid: string;
-}
-/**
- * Event sent when object is updated via PUT request
- */
-export interface EventStoreWebUpdate extends EventWithContext {
-    /**
-     * Type of update
-     */
-    method: "PATCH" | "PUT";
-    /**
-     * Updates to do on the object
-     */
-    updates: any;
-    /**
-     * Target object
-     */
-    object: CoreModel;
-    /**
-     * Emitting store
-     */
-    store: Store;
-}
-/**
- * Event sent when object is deleted via DELETE request
- */
-export interface EventStoreWebDelete extends EventWithContext {
-    /**
-     * Object uuid
-     */
-    object_id: string;
-    /**
-     * Emitting store
-     */
-    store: Store;
-}
 /**
  * Represent a query result on the Store
+ *
+ * @internal — Store-internal type. App code queries via `Model.query()` / `useRepository(Model).query()`.
  */
 export interface StoreFindResult<T> {
     /**
@@ -321,24 +162,44 @@ export interface StoreFindResult<T> {
      */
     filter?: WebdaQL.Expression | true;
 }
+/**
+ * A Store is low-level storage service
+ *
+ * It does not handle any business logic, only CRUD operations
+ *
+ * @internal — Store-internal contract. App code uses `Repository<T>` from `@webda/models`.
+ */
+export interface StoreInterface<T = any> {
+    create(uuid: PrimaryKey<any>, object: any): Promise<any>;
+    get(uuid: PrimaryKey<any>): Promise<any>;
+    update(uuid: PrimaryKey<any>, object: any): Promise<any>;
+    delete(uuid: PrimaryKey<any>): Promise<void>;
+    exists(uuid: PrimaryKey<any>): Promise<boolean>;
+    setAttribute(uuid: PrimaryKey<any>, attribute: string, value: any): Promise<void>;
+    removeAttribute(uuid: PrimaryKey<any>, attribute: string): Promise<void>;
+    upsertItemToCollection(uuid: PrimaryKey<any>, collection: string, item: any, index?: number, itemWriteConditionField?: string, itemWriteCondition?: any): Promise<void>;
+    deleteItemFromCollection(uuid: PrimaryKey<any>, collection: string, index: number, itemWriteConditionField?: string, itemWriteCondition?: any): Promise<void>;
+    find(query: WebdaQLString<T>): Promise<StoreFindResult<any>>;
+    query(query: WebdaQLString<T>): Promise<StoreFindResult<any>>;
+    iterate(query: WebdaQLString<T>): AsyncGenerator;
+    incrementAttributes(uuid: PrimaryKey<any>, info: {
+        property: string;
+        value?: number;
+    }[]): Promise<Date>;
+}
 /**
  * Store parameter
+ *
+ * @internal — Store configuration schema. Authored in `webda.config`/deployment
+ * files; not consumed by app code directly.
  */
 export declare class StoreParameters extends ServiceParameters {
     /**
-     * Webda model to use within the Store
+     * Models managed by this Store.
      *
-     * @default "Webda/CoreModel"
+     * @default ["Webda/RegistryEntry"]
      */
-    model?: string;
-    /**
-     * Additional models
-     *
-     * Allow this store to manage other models
-     *
-     * @default []
-     */
-    additionalModels?: string[];
+    models?: string[];
     /**
      * Allow to load object that does not have the type data
      *
@@ -377,37 +238,26 @@ export declare class StoreParameters extends ServiceParameters {
      * Disable default memory cache
      */
     noCache?: boolean;
-    constructor(params: any, service: Service<any>);
+    /**
+     * Load store parameters with defaults for model type, strict mode, and aliases
+     * @param params - the service parameters
+     * @returns the result
+     */
+    load(params: any): this;
 }
+/**
+ * Aggregate `Store.*` event map.
+ *
+ * @internal — Store-internal type. App code listens on typed repository events
+ * via `useRepository(Model).on("Created" | "Updated" | ...)`.
+ */
 export type StoreEvents = {
     "Store.PartialUpdated": EventStorePartialUpdated;
-    "Store.Save": EventStoreSave;
-    "Store.Saved": EventStoreSaved;
-    "Store.PatchUpdate": EventStorePatchUpdate;
+    "Store.Created": EventStoreCreated;
     "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
- *
- * Therefore they need to handle the cascadeDelete
- */
-export interface MappingService<T = any> {
-    newModel(object: any): T;
-}
 /**
  * This class handle NoSQL storage and mapping (duplication) between NoSQL object
  *
@@ -422,445 +272,95 @@ export interface MappingService<T = any> {
  *   Store.Action: When an action will be done on an object
  *   Store.Actioned: When an action has been done on an object
  *
+ * @internal — Subclassed by store packages only. App code never references a
+ * Store directly: use `useRepository(Model)` or static model methods
+ * (`Model.create()`, `Model.query()`, `Model.ref()`).
  * @category CoreServices
  */
-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
-     */
-    _reverseMap: {
-        mapper: MappingService;
-        property: string;
-    }[];
-    /**
-     * Contains the current model
-     */
-    _model: CoreModelDefinition<T>;
-    /**
-     * Store teh manager hierarchy with their depth
-     */
+declare abstract class Store<K extends StoreParameters = StoreParameters, E extends StoreEvents = StoreEvents> extends Service<K, E> {
+    /** All model classes managed by this store. Index 0 is the legacy "primary" model. */
+    _models: ModelClass[];
+    /** Metadata for each model in `_models`, keyed by Identifier. */
+    _modelMetadatas: Map<string, ModelMetadata>;
+    /** Store the manager hierarchy with their depth */
     _modelsHierarchy: {
         [key: string]: number;
     };
     /**
-     * Contains the current model type
+     * Override the resolved model class for this store at runtime. Used by
+     * the abstract `StoreTest` harness so test fixtures can substitute a
+     * subclass with extra fields in place of the configured model. In
+     * production this is a no-op the framework never calls.
+     * @param model - the substitute model class
      */
-    _modelType: string;
-    /**
-     * Contain the model uuid field
-     */
-    protected _uuidField: string;
+    setModelDefinitionHelper(model: ModelClass): void;
     /**
      * Add metrics counter
      * ' UNION SELECT name, tbl_name as email, "" as col1, "" as col2, "" as col3, "" as col4, "" as col5, "" as col6, "" as col7, "" as col8 FROM sqlite_master --
      * {"email":"' UNION SELECT name as profileImage, tbl_name as email, '' AS column3 FROM sqlite_master --","password":"we"}
      */
     metrics: {
-        cache_invalidations: Counter;
         operations_total: Counter;
         slow_queries_total: Counter;
-        cache_hits: Counter;
         queries: Histogram;
     };
     /**
-     * Load the parameters for a service
+     * Compute and register repositories for all known models based on available stores.
+     *
+     * Called from `Store.init()` so each store's init triggers a recompute.
+     * Cannot be cached: the FIRST store to init (typically `Registry`) would
+     * claim every model with its fallback repository, and subsequent
+     * stores wouldn't get a chance to claim their configured models.
+     * Re-running is idempotent — `registerRepository` overwrites map entries
+     * in place, and the resolution loop is deterministic per current
+     * service/model state.
      */
-    abstract loadParameters(params: any): StoreParameters;
+    static computeStores(): void;
     /**
-     * Retrieve the Model
+     * Retrieve the Models and build the models hierarchy map.
      *
-     * @throws Error if model is not found
+     * Walks `parameters.models[]` (the canonical flat list introduced in Task 1).
+     * If the list is empty or contains only the default "Webda/RegistryEntry"
+     * fallback, the hierarchy stays empty and the store will not claim any model
+     * — preserving the pre-migration fallback behaviour for test-only or
+     * misconfigured stores.
      */
     computeParameters(): void;
+    /**
+     * Log a slow query (placeholder for future implementation)
+     * @param _query - the query to execute
+     * @param _reason - the reason
+     * @param _time - the time
+     */
     logSlowQuery(_query: string, _reason: string, _time: number): void;
     /**
-     * Invalidate a cache entry
-     * @param uid
+     * Initialize the store
+     * @returns this for chaining
      */
-    invalidateCache(uid: string): Promise<void>;
+    init(): Promise<this>;
     /**
      * @override
      */
     initMetrics(): void;
     /**
-     * Return Store current model
-     * @returns
+     * All models managed by this store.
+     * @returns the array of model classes managed by this store
      */
-    getModel(): CoreModelDefinition;
+    getModels(): ModelClass[];
     /**
      * Return if a model is handled by the store
-     * @param model
+     * @param model - the model to use
      * @return distance from the managed class -1 means not managed, 0 manage exactly this model, >0 manage an ancestor model
      *
+     * @returns the result number
      */
-    handleModel(model: Constructor<CoreModel> | CoreModel): number;
-    /**
-     * Get From Cache or main
-     * @param uuid
-     * @param raiseIfNotFound
-     * @returns
-     */
-    _getFromCache(uuid: string, raiseIfNotFound?: boolean): Promise<T>;
-    /**
-     * Get object from store
-     * @param uid
-     * @returns
-     */
-    getObject(uid: string): Promise<T>;
-    static getOpenAPI(): void;
-    /**
-     * OVerwrite the model
-     * Used mainly in test
-     */
-    setModel(model: CoreModelDefinition<T>): void;
-    /**
-     * We should ignore exception from the store
-     */
-    cacheStorePatchException(): void;
-    /**
-     * Init a model from the current stored data
-     *
-     * Initial the reverse map as well
-     *
-     * @param object
-     * @returns
-     */
-    protected initModel(object?: any): T;
-    /**
-     * Get a new model with this data preloaded
-     * @param object
-     * @returns
-     */
-    newModel(object?: any): T;
-    /**
-     * Add reverse map information
-     *
-     * @param prop
-     * @param cascade
-     * @param store
-     */
-    addReverseMap(prop: string, store: MappingService): void;
-    /**
-     * Increment attributes of an object
-     *
-     * @param uid
-     * @param info
-     * @returns
-     */
-    incrementAttributes<FK extends FilterAttributes<T, number>>(uid: string, info: {
-        property: FK;
-        value: number;
-    }[]): Promise<Date>;
-    /**
-     * Helper function that call incrementAttributes
-     * @param uid
-     * @param prop
-     * @param value
-     * @returns
-     */
-    incrementAttribute<FK extends FilterAttributes<T, number>>(uid: string, prop: FK, value: number): Promise<Date>;
-    /**
-     * Add or update an item to an array in the model
-     *
-     * @param uid of the model
-     * @param prop of the model to add in
-     * @param item to add in the array
-     * @param index if specified update item in this index
-     * @param itemWriteCondition value of the condition to test (in case of update)
-     * @param itemWriteConditionField field to read the condition from (in case of update)
-     */
-    upsertItemToCollection<FK extends FilterAttributes<T, Array<any>>>(uid: string, prop: FK, item: any, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<Date>;
-    /**
-     * Remove an item from an array in the model
-     *
-     * @param uid of the model
-     * @param prop of the model to remove from
-     * @param index of the item to remove in the array
-     * @param itemWriteCondition value of the condition
-     * @param itemWriteConditionField field to read the condition from
-     */
-    deleteItemFromCollection<FK extends FilterAttributes<T, Array<any>>>(uid: string, prop: FK, index: number, itemWriteCondition: any, itemWriteConditionField?: string): Promise<Date>;
-    /**
-     * Iterate through the results
-     *
-     * This can be resource consuming
-     *
-     * @param query
-     * @param context
-     */
-    iterate(query?: string, context?: OperationContext): AsyncGenerator<T>;
-    /**
-     * Query all the results
-     *
-     *
-     * @param query
-     * @param context
-     * @returns
-     * @deprecated use iterate instead
-     */
-    queryAll(query: string, context?: OperationContext): Promise<T[]>;
-    /**
-     * Check that __type Comparison is only used with = and CONTAINS
-     * If CONTAINS is used, move __type to __types
-     * If __type = store._model, remove it
-     */
-    queryTypeUpdater(query: WebdaQL.Query): WebdaQL.Query;
-    /**
-     * Query store with WebdaQL
-     * @param query
-     * @param context to apply permission
-     */
-    query(query: string, context?: OperationContext): Promise<{
-        results: T[];
-        continuationToken?: string;
-    }>;
-    /**
-     * Handle StoreEvent and update cache based on it
-     * Then emit the event, it allows the cache to be updated
-     * before listeners are called
-     *
-     * @param event
-     * @param data
-     */
-    emitStoreEvent<Key extends keyof StoreEvents>(event: Key, data: E[Key] & {
-        emitterId?: string;
-    }): Promise<void>;
-    /**
-     * Save an object
-     *
-     * @param {Object} Object to save
-     * @param {String} Uuid to use, if not specified take the object.uuid or generate one if not found
-     * @return {Promise} with saved object
-     *
-     * Might want to rename to create
-     */
-    save(object: any, ctx?: OperationContext): Promise<T>;
-    /**
-     *
-     * @param object
-     * @param ctx
-     * @returns
-     */
-    create(object: any, ctx?: OperationContext): Promise<any>;
-    /**
-     * Patch an object
-     *
-     * @param object
-     * @param reverseMap
-     * @returns
-     */
-    patch<FK extends keyof T>(object: Partial<T>, reverseMap?: boolean, conditionField?: FK | null, conditionValue?: any): Promise<T | undefined>;
-    /**
-     * Check if an UpdateCondition is met
-     * @param model
-     * @param conditionField
-     * @param condition
-     * @param uid
-     */
-    checkUpdateCondition<CK extends keyof T>(model: T, conditionField?: CK, condition?: any, uid?: string): void;
-    /**
-     * Check if an UpdateCondition is met
-     * @param model
-     * @param conditionField
-     * @param condition
-     * @param uid
-     */
-    checkCollectionUpdateCondition<FK extends FilterAttributes<T, Array<any>>, CK extends keyof T>(model: T, collection: FK, conditionField?: CK, condition?: any, index?: number): void;
+    handleModel(model: ModelClass | Model): number;
     /**
-     * Update conditionally
-     * @param uuid
-     * @param updates
-     * @param conditionField
-     * @param condition
+     * Check that keys are valid
+     * All keys of model stored in a Store must have the same type of primary key
      */
-    conditionalPatch<CK extends keyof T>(uuid: string, updates: Partial<T>, conditionField: CK, condition: any): Promise<boolean>;
-    /**
-     *
-     * @param model
-     * @param prop
-     * @param item
-     * @param index
-     * @param itemWriteCondition
-     * @param itemWriteConditionField
-     * @param updateDate
-     */
-    simulateUpsertItemToCollection<FK extends FilterAttributes<T, Array<any>>>(model: T, prop: FK, item: any, updateDate: Date, index?: number, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<void>;
-    /**
-     * Update an object
-     *
-     * If no attribute can be updated then return undefined
-     *
-     * @param {Object} Object to save
-     * @param {Boolean} reverseMap internal use only, for disable map resolution
-     * @return {Promise} with saved object
-     */
-    update<CK extends keyof T>(object: any, reverseMap?: boolean, partial?: boolean, conditionField?: CK | null, conditionValue?: any): Promise<T | undefined>;
-    /**
-     *
-     */
-    recomputeTypeShortId(): Promise<void>;
-    /**
-     * Ensure model aliases are not used in this store
-     *
-     * So alias can be cleaned
-     */
-    cleanModelAliases(): Promise<void>;
-    /**
-     * Recompute the __types for all objects (storeMigration.Registry.typesCompute)
-     */
-    recomputeTypes(): Promise<void>;
-    /**
-     * Delete a migration
-     * @param name
-     */
-    cancelMigration(name: string): Promise<void>;
-    /**
-     * Get a migration
-     * @param name
-     */
-    getMigration(name: string): Promise<any>;
-    /**
-     * Add a migration mechanism to store
-     * @param name
-     * @param patcher
-     */
-    migration(name: string, patcher: (object: T) => Promise<Partial<T> | (() => Promise<void>) | undefined>, batchSize?: number): Promise<void>;
-    /**
-     * Remove an attribute from an object
-     *
-     * @param uuid
-     * @param attribute
-     * @returns
-     */
-    removeAttribute<CK extends keyof T>(uuid: string, attribute: CK, itemWriteCondition?: any, itemWriteConditionField?: CK): Promise<void>;
-    /**
-     * Cascade delete a related object
-     *
-     * @param obj
-     * @param uuid
-     * @returns
-     */
-    cascadeDelete(obj: CoreModel, _uuid: string): Promise<any>;
-    /**
-     * Delete an object
-     *
-     * @param {String} uuid to delete
-     * @return {Promise} the deletion promise
-     */
-    delete<CK extends keyof T>(uid: string | T, writeCondition?: any, writeConditionField?: CK): Promise<void>;
-    /**
-     * By default we cannot know if the store will trigger or not
-     *
-     * @param id
-     * @param callback
-     */
-    canTriggerConfiguration(_id: string, _callback: () => void): boolean;
-    /**
-     * Provide a way to store configuration in store
-     * @param {string} id
-     * @returns {Promise<Map<string, any>>}
-     */
-    getConfiguration(id: string): Promise<{
-        [key: string]: any;
-    }>;
-    /**
-     * Upsert the uuid object
-     * @param uuid
-     * @param data
-     */
-    put(uuid: string, data: Partial<T>): Promise<T>;
-    /**
-     * Get an object
-     *
-     * @param {String} uuid to get
-     * @return {Promise} the object retrieved ( can be undefined if not found )
-     */
-    get(uid: string, ctx?: OperationContext, defaultValue?: any): Promise<T>;
-    /**
-     * Set one attribute in an object
-     *
-     * this is an helper function that calls patch
-     *
-     * @param uid of the object
-     * @param property to update1
-     * @param value new value
-     * @returns
-     */
-    setAttribute<CK extends keyof T>(uid: string, property: CK, value: any): Promise<void>;
-    /**
-     * @override
-     */
-    protected simulateFind(query: WebdaQL.Query, uuids: string[]): Promise<StoreFindResult<T>>;
-    getOpenApiReplacements(): {
-        modelName: string;
-    };
-    /**
-     * Return the model uuid field
-     */
-    getUuidField(): string;
-    /**
-     * Check if an object exists
-     * @abstract
-     * @params {String} uuid of the object or the object
-     */
-    exists(uid: string | CoreModel): Promise<boolean>;
-    /**
-     * Search within the store
-     */
-    abstract find(query: WebdaQL.Query): Promise<StoreFindResult<T>>;
-    /**
-     * Check if an object exists
-     * @abstract
-     */
-    abstract _exists(uid: string): Promise<boolean>;
-    /**
-     * The underlying store should recheck writeCondition only if it does not require
-     * another get()
-     *
-     * @param uid
-     * @param writeCondition
-     * @param itemWriteConditionField
-     */
-    protected abstract _delete(uid: string, writeCondition?: any, itemWriteConditionField?: string): Promise<void>;
-    /**
-     * Retrieve an element from the store
-     *
-     * @param uid to retrieve
-     * @param raiseIfNotFound raise an StoreNotFound exception if not found
-     */
-    protected abstract _get(uid: string, raiseIfNotFound?: boolean): Promise<T>;
-    /**
-     * Get an object
-     *
-     * @param {Array} uuid to gets if undefined then retrieve the all table
-     * @return {Promise} the objects retrieved ( can be [] if not found )
-     */
-    abstract getAll(list?: string[]): Promise<T[]>;
-    protected abstract _update(object: any, uid: string, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<any>;
-    protected abstract _patch(object: any, uid: string, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<any>;
-    protected abstract _removeAttribute(uuid: string, attribute: string, itemWriteCondition?: any, itemWriteConditionField?: string): Promise<void>;
-    /**
-     * Save within the store
-     * @param object
-     */
-    protected abstract _save(object: T): Promise<any>;
-    /**
-     * Increment the attribute
-     * @param uid
-     * @param prop
-     * @param value
-     * @param updateDate
-     */
-    protected abstract _incrementAttributes(uid: string, params: {
-        property: string;
-        value: number;
-    }[], updateDate: Date): Promise<any>;
-    protected abstract _upsertItemToCollection(uid: string, prop: string, item: any, index: number, itemWriteCondition: any, itemWriteConditionField: string, updateDate: Date): Promise<any>;
-    protected abstract _deleteItemFromCollection(uid: string, prop: string, index: number, itemWriteCondition: any, itemWriteConditionField: string, updateDate: Date): Promise<any>;
+    checkKeys(): void;
+    abstract getRepository<T extends ModelClass>(model: T): Repository<T>;
 }
 export { Store };
 //# sourceMappingURL=store.d.ts.map