@twin.org/entity-storage-service 0.0.1-next.8 → 0.0.1

package/dist/cjs/index.cjs

@@ -224,7 +224,7 @@ async function entityStorageRemove(httpRequestContext, componentName, request) {
 async function entityStorageList(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.query(apiModels.HttpParameterHelper.objectFromString(request.query?.conditions), apiModels.HttpParameterHelper.objectFromString(request.query?.sortProperties), apiModels.HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, core.Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    const result = await component.query(apiModels.HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, apiModels.HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, core.Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         body: result
     };
@@ -259,8 +259,6 @@ class EntityStorageService {
     /**
      * Create a new instance of EntityStorageService.
      * @param options The dependencies for the entity storage service.
-     * @param options.config The configuration for the service.
-     * @param options.entityStorageType The entity storage type.
      */
     constructor(options) {
         core.Guards.string(this.CLASS_NAME, "options.entityStorageType", options.entityStorageType);
@@ -277,15 +275,24 @@ class EntityStorageService {
      */
     async set(entity, userIdentity, nodeIdentity) {
         core.Guards.object(this.CLASS_NAME, "entity", entity);
+        const conditions = [];
         if (this._includeUserIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            conditions.push({
+                property: "userIdentity",
+                value: userIdentity
+            });
             core.ObjectHelper.propertySet(entity, "userIdentity", userIdentity);
         }
         if (this._includeNodeIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            conditions.push({
+                property: "nodeIdentity",
+                value: nodeIdentity
+            });
             core.ObjectHelper.propertySet(entity, "nodeIdentity", nodeIdentity);
         }
-        return this._entityStorage.set(entity);
+        return this._entityStorage.set(entity, conditions);
     }
     /**
      * Get an entity.
@@ -296,61 +303,91 @@ class EntityStorageService {
      * @returns The object if it can be found or undefined.
      */
     async get(id, secondaryIndex, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        return this.internalGet(id, secondaryIndex, userIdentity, nodeIdentity);
+    }
+    /**
+     * Remove the entity.
+     * @param id The id of the entity to remove.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns Nothing.
+     */
+    async remove(id, userIdentity, nodeIdentity) {
         core.Guards.stringValue(this.CLASS_NAME, "id", id);
         const conditions = [];
         if (this._includeUserIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
             conditions.push({
                 property: "userIdentity",
-                comparison: entity.ComparisonOperator.Equals,
                 value: userIdentity
             });
         }
         if (this._includeNodeIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
             conditions.push({
+                property: "nodeIdentity",
+                value: nodeIdentity
+            });
+        }
+        await this._entityStorage.remove(id, conditions);
+    }
+    /**
+     * Query all the entities which match the conditions.
+     * @param conditions The conditions to match for the entities.
+     * @param orderBy The order for the results.
+     * @param orderByDirection The direction for the order, defaults to ascending.
+     * @param properties The optional properties to return, defaults to all.
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     */
+    async query(conditions, orderBy, orderByDirection, properties, cursor, pageSize, userIdentity, nodeIdentity) {
+        const finalConditions = {
+            conditions: [],
+            logicalOperator: entity.LogicalOperator.And
+        };
+        if (this._includeNodeIdentity) {
+            core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            finalConditions.conditions.push({
                 property: "nodeIdentity",
                 comparison: entity.ComparisonOperator.Equals,
                 value: nodeIdentity
             });
         }
-        if (core.Is.stringValue(secondaryIndex)) {
-            conditions.push({
-                property: secondaryIndex,
+        if (this._includeUserIdentity) {
+            core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            finalConditions.conditions.push({
+                property: "userIdentity",
                 comparison: entity.ComparisonOperator.Equals,
-                value: id
+                value: userIdentity
             });
         }
-        if (conditions.length === 0) {
-            const entity = await this._entityStorage.get(id, secondaryIndex);
-            if (core.Is.empty(entity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
+        if (!core.Is.empty(conditions)) {
+            finalConditions.conditions.push(conditions);
+        }
+        const result = await this._entityStorage.query(finalConditions.conditions.length > 0 ? finalConditions : undefined, core.Is.stringValue(orderBy)
+            ? [{ property: orderBy, sortDirection: orderByDirection ?? entity.SortDirection.Ascending }]
+            : undefined, properties, cursor, pageSize);
+        for (const entity of result.entities) {
             core.ObjectHelper.propertyDelete(entity, "nodeIdentity");
             core.ObjectHelper.propertyDelete(entity, "userIdentity");
-            return entity;
         }
-        const results = await this._entityStorage.query({
-            conditions,
-            logicalOperator: entity.LogicalOperator.And
-        }, undefined, undefined, undefined, 1);
-        const entity$1 = results.entities[0];
-        if (core.Is.empty(entity$1)) {
-            throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-        }
-        core.ObjectHelper.propertyDelete(entity$1, "nodeIdentity");
-        core.ObjectHelper.propertyDelete(entity$1, "userIdentity");
-        return entity$1;
+        return result;
     }
     /**
-     * Remove the entity.
-     * @param id The id of the entity to remove.
+     * Get an entity.
+     * @param id The id of the entity to get, or the index value if secondaryIndex is set.
+     * @param secondaryIndex Get the item using a secondary index.
      * @param userIdentity The user identity to use with storage operations.
      * @param nodeIdentity The node identity to use with storage operations.
-     * @returns Nothing.
+     * @returns The object if it can be found or throws.
+     * @internal
      */
-    async remove(id, userIdentity, nodeIdentity) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async internalGet(id, secondaryIndex, userIdentity, nodeIdentity) {
         const conditions = [];
         if (this._includeUserIdentity) {
             core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
@@ -368,77 +405,39 @@ class EntityStorageService {
                 value: nodeIdentity
             });
         }
-        if (conditions.length === 0) {
-            const entity = await this._entityStorage.get(id);
-            if (core.Is.empty(entity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
-            await this._entityStorage.remove(id);
-        }
-        else {
-            const schema = this._entityStorage.getSchema();
-            const primaryKey = entity.EntitySchemaHelper.getPrimaryKey(schema);
+        if (core.Is.stringValue(secondaryIndex)) {
             conditions.push({
-                property: primaryKey.property,
+                property: secondaryIndex,
                 comparison: entity.ComparisonOperator.Equals,
                 value: id
             });
+        }
+        let entity$1;
+        if (conditions.length === 0) {
+            entity$1 = await this._entityStorage.get(id, secondaryIndex);
+        }
+        else {
+            if (!core.Is.stringValue(secondaryIndex)) {
+                const schema = this._entityStorage.getSchema();
+                const primaryKey = entity.EntitySchemaHelper.getPrimaryKey(schema);
+                conditions.unshift({
+                    property: primaryKey.property,
+                    comparison: entity.ComparisonOperator.Equals,
+                    value: id
+                });
+            }
             const results = await this._entityStorage.query({
                 conditions,
                 logicalOperator: entity.LogicalOperator.And
             }, undefined, undefined, undefined, 1);
-            if (results.entities.length > 0) {
-                const firstEntity = results.entities[0];
-                await this._entityStorage.remove(firstEntity[primaryKey.property]);
-            }
-            else {
-                throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
+            entity$1 = results.entities[0];
         }
-    }
-    /**
-     * Query all the entities which match the conditions.
-     * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
-     * @param properties The optional properties to return, defaults to all.
-     * @param cursor The cursor to request the next page of entities.
-     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
-     * @param userIdentity The user identity to use with storage operations.
-     * @param nodeIdentity The node identity to use with storage operations.
-     * @returns All the entities for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     */
-    async query(conditions, sortProperties, properties, cursor, pageSize, userIdentity, nodeIdentity) {
-        const conditionsList = [];
-        if (this._includeUserIdentity) {
-            core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            conditionsList.push({
-                property: "userIdentity",
-                comparison: entity.ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        if (this._includeNodeIdentity) {
-            core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-            conditionsList.push({
-                property: "nodeIdentity",
-                comparison: entity.ComparisonOperator.Equals,
-                value: nodeIdentity
-            });
-        }
-        const finalConditions = {
-            conditions: conditionsList,
-            logicalOperator: entity.LogicalOperator.And
-        };
-        if (!core.Is.empty(conditions)) {
-            finalConditions.conditions.push(conditions);
-        }
-        const result = await this._entityStorage.query(finalConditions.conditions.length > 0 ? finalConditions : undefined, sortProperties, properties, cursor, pageSize);
-        for (const entity of result.entities) {
-            core.ObjectHelper.propertyDelete(entity, "nodeIdentity");
-            core.ObjectHelper.propertyDelete(entity, "userIdentity");
+        if (core.Is.empty(entity$1)) {
+            throw new core.NotFoundError(this.CLASS_NAME, "entityNotFound", id);
         }
-        return result;
+        core.ObjectHelper.propertyDelete(entity$1, "nodeIdentity");
+        core.ObjectHelper.propertyDelete(entity$1, "userIdentity");
+        return entity$1;
     }
 }
 

package/dist/esm/index.mjs

@@ -1,7 +1,7 @@
 import { HttpParameterHelper } from '@twin.org/api-models';
 import { StringHelper, Guards, ComponentFactory, Coerce, ObjectHelper, Is, NotFoundError } from '@twin.org/core';
 import { HttpStatusCode } from '@twin.org/web';
-import { ComparisonOperator, LogicalOperator, EntitySchemaHelper } from '@twin.org/entity';
+import { LogicalOperator, ComparisonOperator, SortDirection, EntitySchemaHelper } from '@twin.org/entity';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 
 // Copyright 2024 IOTA Stiftung.
@@ -222,7 +222,7 @@ async function entityStorageRemove(httpRequestContext, componentName, request) {
 async function entityStorageList(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
     const component = ComponentFactory.get(componentName);
-    const result = await component.query(HttpParameterHelper.objectFromString(request.query?.conditions), HttpParameterHelper.objectFromString(request.query?.sortProperties), HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    const result = await component.query(HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         body: result
     };
@@ -257,8 +257,6 @@ class EntityStorageService {
     /**
      * Create a new instance of EntityStorageService.
      * @param options The dependencies for the entity storage service.
-     * @param options.config The configuration for the service.
-     * @param options.entityStorageType The entity storage type.
      */
     constructor(options) {
         Guards.string(this.CLASS_NAME, "options.entityStorageType", options.entityStorageType);
@@ -275,15 +273,24 @@ class EntityStorageService {
      */
     async set(entity, userIdentity, nodeIdentity) {
         Guards.object(this.CLASS_NAME, "entity", entity);
+        const conditions = [];
         if (this._includeUserIdentity) {
             Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            conditions.push({
+                property: "userIdentity",
+                value: userIdentity
+            });
             ObjectHelper.propertySet(entity, "userIdentity", userIdentity);
         }
         if (this._includeNodeIdentity) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            conditions.push({
+                property: "nodeIdentity",
+                value: nodeIdentity
+            });
             ObjectHelper.propertySet(entity, "nodeIdentity", nodeIdentity);
         }
-        return this._entityStorage.set(entity);
+        return this._entityStorage.set(entity, conditions);
     }
     /**
      * Get an entity.
@@ -294,61 +301,91 @@ class EntityStorageService {
      * @returns The object if it can be found or undefined.
      */
     async get(id, secondaryIndex, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        return this.internalGet(id, secondaryIndex, userIdentity, nodeIdentity);
+    }
+    /**
+     * Remove the entity.
+     * @param id The id of the entity to remove.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns Nothing.
+     */
+    async remove(id, userIdentity, nodeIdentity) {
         Guards.stringValue(this.CLASS_NAME, "id", id);
         const conditions = [];
         if (this._includeUserIdentity) {
             Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
             conditions.push({
                 property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
                 value: userIdentity
             });
         }
         if (this._includeNodeIdentity) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
             conditions.push({
+                property: "nodeIdentity",
+                value: nodeIdentity
+            });
+        }
+        await this._entityStorage.remove(id, conditions);
+    }
+    /**
+     * Query all the entities which match the conditions.
+     * @param conditions The conditions to match for the entities.
+     * @param orderBy The order for the results.
+     * @param orderByDirection The direction for the order, defaults to ascending.
+     * @param properties The optional properties to return, defaults to all.
+     * @param cursor The cursor to request the next page of entities.
+     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns All the entities for the storage matching the conditions,
+     * and a cursor which can be used to request more entities.
+     */
+    async query(conditions, orderBy, orderByDirection, properties, cursor, pageSize, userIdentity, nodeIdentity) {
+        const finalConditions = {
+            conditions: [],
+            logicalOperator: LogicalOperator.And
+        };
+        if (this._includeNodeIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            finalConditions.conditions.push({
                 property: "nodeIdentity",
                 comparison: ComparisonOperator.Equals,
                 value: nodeIdentity
             });
         }
-        if (Is.stringValue(secondaryIndex)) {
-            conditions.push({
-                property: secondaryIndex,
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            finalConditions.conditions.push({
+                property: "userIdentity",
                 comparison: ComparisonOperator.Equals,
-                value: id
+                value: userIdentity
             });
         }
-        if (conditions.length === 0) {
-            const entity = await this._entityStorage.get(id, secondaryIndex);
-            if (Is.empty(entity)) {
-                throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
+        if (!Is.empty(conditions)) {
+            finalConditions.conditions.push(conditions);
+        }
+        const result = await this._entityStorage.query(finalConditions.conditions.length > 0 ? finalConditions : undefined, Is.stringValue(orderBy)
+            ? [{ property: orderBy, sortDirection: orderByDirection ?? SortDirection.Ascending }]
+            : undefined, properties, cursor, pageSize);
+        for (const entity of result.entities) {
             ObjectHelper.propertyDelete(entity, "nodeIdentity");
             ObjectHelper.propertyDelete(entity, "userIdentity");
-            return entity;
         }
-        const results = await this._entityStorage.query({
-            conditions,
-            logicalOperator: LogicalOperator.And
-        }, undefined, undefined, undefined, 1);
-        const entity = results.entities[0];
-        if (Is.empty(entity)) {
-            throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-        }
-        ObjectHelper.propertyDelete(entity, "nodeIdentity");
-        ObjectHelper.propertyDelete(entity, "userIdentity");
-        return entity;
+        return result;
     }
     /**
-     * Remove the entity.
-     * @param id The id of the entity to remove.
+     * Get an entity.
+     * @param id The id of the entity to get, or the index value if secondaryIndex is set.
+     * @param secondaryIndex Get the item using a secondary index.
      * @param userIdentity The user identity to use with storage operations.
      * @param nodeIdentity The node identity to use with storage operations.
-     * @returns Nothing.
+     * @returns The object if it can be found or throws.
+     * @internal
      */
-    async remove(id, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async internalGet(id, secondaryIndex, userIdentity, nodeIdentity) {
         const conditions = [];
         if (this._includeUserIdentity) {
             Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
@@ -366,77 +403,39 @@ class EntityStorageService {
                 value: nodeIdentity
             });
         }
-        if (conditions.length === 0) {
-            const entity = await this._entityStorage.get(id);
-            if (Is.empty(entity)) {
-                throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
-            await this._entityStorage.remove(id);
-        }
-        else {
-            const schema = this._entityStorage.getSchema();
-            const primaryKey = EntitySchemaHelper.getPrimaryKey(schema);
+        if (Is.stringValue(secondaryIndex)) {
             conditions.push({
-                property: primaryKey.property,
+                property: secondaryIndex,
                 comparison: ComparisonOperator.Equals,
                 value: id
             });
+        }
+        let entity;
+        if (conditions.length === 0) {
+            entity = await this._entityStorage.get(id, secondaryIndex);
+        }
+        else {
+            if (!Is.stringValue(secondaryIndex)) {
+                const schema = this._entityStorage.getSchema();
+                const primaryKey = EntitySchemaHelper.getPrimaryKey(schema);
+                conditions.unshift({
+                    property: primaryKey.property,
+                    comparison: ComparisonOperator.Equals,
+                    value: id
+                });
+            }
             const results = await this._entityStorage.query({
                 conditions,
                 logicalOperator: LogicalOperator.And
             }, undefined, undefined, undefined, 1);
-            if (results.entities.length > 0) {
-                const firstEntity = results.entities[0];
-                await this._entityStorage.remove(firstEntity[primaryKey.property]);
-            }
-            else {
-                throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-            }
+            entity = results.entities[0];
         }
-    }
-    /**
-     * Query all the entities which match the conditions.
-     * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
-     * @param properties The optional properties to return, defaults to all.
-     * @param cursor The cursor to request the next page of entities.
-     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
-     * @param userIdentity The user identity to use with storage operations.
-     * @param nodeIdentity The node identity to use with storage operations.
-     * @returns All the entities for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     */
-    async query(conditions, sortProperties, properties, cursor, pageSize, userIdentity, nodeIdentity) {
-        const conditionsList = [];
-        if (this._includeUserIdentity) {
-            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            conditionsList.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        if (this._includeNodeIdentity) {
-            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-            conditionsList.push({
-                property: "nodeIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: nodeIdentity
-            });
-        }
-        const finalConditions = {
-            conditions: conditionsList,
-            logicalOperator: LogicalOperator.And
-        };
-        if (!Is.empty(conditions)) {
-            finalConditions.conditions.push(conditions);
-        }
-        const result = await this._entityStorage.query(finalConditions.conditions.length > 0 ? finalConditions : undefined, sortProperties, properties, cursor, pageSize);
-        for (const entity of result.entities) {
-            ObjectHelper.propertyDelete(entity, "nodeIdentity");
-            ObjectHelper.propertyDelete(entity, "userIdentity");
+        if (Is.empty(entity)) {
+            throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
         }
-        return result;
+        ObjectHelper.propertyDelete(entity, "nodeIdentity");
+        ObjectHelper.propertyDelete(entity, "userIdentity");
+        return entity;
     }
 }
 

package/dist/types/entityStorageService.d.ts

@@ -1,6 +1,6 @@
-import { type SortDirection, type EntityCondition } from "@twin.org/entity";
+import { type EntityCondition, SortDirection } from "@twin.org/entity";
 import { type IEntityStorageComponent } from "@twin.org/entity-storage-models";
-import type { IEntityStorageConfig } from "./models/IEntityStorageConfig";
+import type { IEntityStorageServiceConstructorOptions } from "./models/IEntityStorageServiceConstructorOptions";
 /**
  * Class for performing entity service operations.
  */
@@ -12,13 +12,8 @@ export declare class EntityStorageService<T = any> implements IEntityStorageComp
     /**
      * Create a new instance of EntityStorageService.
      * @param options The dependencies for the entity storage service.
-     * @param options.config The configuration for the service.
-     * @param options.entityStorageType The entity storage type.
      */
-    constructor(options: {
-        entityStorageType: string;
-        config?: IEntityStorageConfig;
-    });
+    constructor(options: IEntityStorageServiceConstructorOptions);
     /**
      * Set an entity.
      * @param entity The entity to set.
@@ -47,7 +42,8 @@ export declare class EntityStorageService<T = any> implements IEntityStorageComp
     /**
      * Query all the entities which match the conditions.
      * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
+     * @param orderBy The order for the results.
+     * @param orderByDirection The direction for the order, defaults to ascending.
      * @param properties The optional properties to return, defaults to all.
      * @param cursor The cursor to request the next page of entities.
      * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
@@ -56,10 +52,7 @@ export declare class EntityStorageService<T = any> implements IEntityStorageComp
      * @returns All the entities for the storage matching the conditions,
      * and a cursor which can be used to request more entities.
      */
-    query(conditions?: EntityCondition<T>, sortProperties?: {
-        property: keyof T;
-        sortDirection: SortDirection;
-    }[], properties?: (keyof T)[], cursor?: string, pageSize?: number, userIdentity?: string, nodeIdentity?: string): Promise<{
+    query(conditions?: EntityCondition<T>, orderBy?: keyof T, orderByDirection?: SortDirection, properties?: (keyof T)[], cursor?: string, pageSize?: number, userIdentity?: string, nodeIdentity?: string): Promise<{
         /**
          * The entities, which can be partial if a limited keys list was provided.
          */

package/dist/types/index.d.ts

@@ -2,4 +2,5 @@ export * from "./entityStorageRoutes";
 export * from "./entityStorageService";
 export * from "./models/IEntityStorageConfig";
 export * from "./models/IEntityStorageRoutesExamples";
+export * from "./models/IEntityStorageServiceConstructorOptions";
 export * from "./restEntryPoints";

package/dist/types/models/IEntityStorageServiceConstructorOptions.d.ts

@@ -0,0 +1,14 @@
+import type { IEntityStorageConfig } from "./IEntityStorageConfig";
+/**
+ * Options for the Entity Storage Service constructor.
+ */
+export interface IEntityStorageServiceConstructorOptions {
+    /**
+     * The type of the entity storage.
+     */
+    entityStorageType: string;
+    /**
+     * The configuration for the service.
+     */
+    config?: IEntityStorageConfig;
+}