@twin.org/entity-storage-service 0.0.2-next.9 → 0.0.3-next.1

package/dist/esm/index.mjs

@@ -1,412 +0,0 @@
-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 { LogicalOperator, ComparisonOperator, SortDirection, EntitySchemaHelper } from '@twin.org/entity';
-import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * The source used when communicating about these routes.
- */
-const ROUTES_SOURCE = "entityStorageRoutes";
-/**
- * The tag to associate with the routes.
- */
-const tagsEntityStorage = [
-    {
-        name: "EntityStorage",
-        description: "Endpoints which are modelled to access an entity storage contract."
-    }
-];
-/**
- * The REST routes for entity storage.
- * @param baseRouteName Prefix to prepend to the paths.
- * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
- * @param options Additional options for the routes.
- * @param options.typeName Optional type name to use in the routes, defaults to Entity Storage.
- * @param options.tagName Optional name to use in OpenAPI spec for tag.
- * @param options.examples Optional examples to use in the routes.
- * @returns The generated routes.
- */
-function generateRestRoutesEntityStorage(baseRouteName, componentName, options) {
-    const typeName = options?.typeName ?? "Entity Storage";
-    const lowerName = typeName.toLowerCase();
-    const camelTypeName = StringHelper.camelCase(typeName);
-    const setRoute = {
-        operationId: `${camelTypeName}Set`,
-        summary: `Set an entry in ${lowerName}.`,
-        tag: options?.tagName ?? tagsEntityStorage[0].name,
-        method: "POST",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => entityStorageSet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IEntityStorageSetRequest",
-            examples: options?.examples?.set?.requestExamples ?? [
-                {
-                    id: `${camelTypeName}SetRequestExample`,
-                    request: {
-                        body: {
-                            id: "12345",
-                            name: "My Item"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            }
-        ]
-    };
-    const getRoute = {
-        operationId: `${camelTypeName}Get`,
-        summary: `Get an entry from ${lowerName}.`,
-        tag: options?.tagName ?? tagsEntityStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => entityStorageGet(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IEntityStorageGetRequest",
-            examples: options?.examples?.get?.requestExamples ?? [
-                {
-                    id: `${camelTypeName}GetRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "12345"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IEntityStorageGetResponse",
-                examples: options?.examples?.get?.responseExamples ?? [
-                    {
-                        id: `${camelTypeName}GetResponseExample`,
-                        response: {
-                            body: {
-                                id: "12345",
-                                name: "My Item"
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const removeRoute = {
-        operationId: `${camelTypeName}Remove`,
-        summary: `Remove an entry from ${lowerName}.`,
-        tag: options?.tagName ?? tagsEntityStorage[0].name,
-        method: "DELETE",
-        path: `${baseRouteName}/:id`,
-        handler: async (httpRequestContext, request) => entityStorageRemove(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IEntityStorageRemoveRequest",
-            examples: options?.examples?.remove?.requestExamples ?? [
-                {
-                    id: `${camelTypeName}RemoveRequestExample`,
-                    request: {
-                        pathParams: {
-                            id: "12345"
-                        }
-                    }
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "INoContentResponse"
-            },
-            {
-                type: "INotFoundResponse"
-            }
-        ]
-    };
-    const listRoute = {
-        operationId: `${camelTypeName}List`,
-        summary: `Query entries from ${lowerName}.`,
-        tag: options?.tagName ?? tagsEntityStorage[0].name,
-        method: "GET",
-        path: `${baseRouteName}/`,
-        handler: async (httpRequestContext, request) => entityStorageList(httpRequestContext, componentName, request),
-        requestType: {
-            type: "IEntityStorageListRequest",
-            examples: options?.examples?.list?.requestExamples ?? [
-                {
-                    id: `${camelTypeName}ListRequestExample`,
-                    request: {}
-                }
-            ]
-        },
-        responseType: [
-            {
-                type: "IEntityStorageListResponse",
-                examples: options?.examples?.list?.responseExamples ?? [
-                    {
-                        id: `${camelTypeName}ListResponseExample`,
-                        response: {
-                            body: {
-                                entities: [{ id: "12345", name: "My Item" }]
-                            }
-                        }
-                    }
-                ]
-            }
-        ]
-    };
-    return [setRoute, getRoute, removeRoute, listRoute];
-}
-/**
- * Set the entry in entity storage.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function entityStorageSet(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    const component = ComponentFactory.get(componentName);
-    await component.set(request.body, httpRequestContext.userIdentity);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * Get the entry from entity storage.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function entityStorageGet(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const component = ComponentFactory.get(componentName);
-    const item = await component.get(request.pathParams.id, request.query?.secondaryIndex, httpRequestContext.userIdentity);
-    return {
-        body: item
-    };
-}
-/**
- * Remove the entry from entity storage.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-async function entityStorageRemove(httpRequestContext, componentName, request) {
-    Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    const component = ComponentFactory.get(componentName);
-    await component.remove(request.pathParams.id, httpRequestContext.userIdentity);
-    return {
-        statusCode: HttpStatusCode.noContent
-    };
-}
-/**
- * Query the entries from entity storage.
- * @param httpRequestContext The request context for the API.
- * @param componentName The name of the component to use in the routes.
- * @param request The request.
- * @returns The response object with additional http response properties.
- */
-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), request.query?.orderBy, request.query?.orderByDirection, HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity);
-    return {
-        body: result
-    };
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing entity service operations.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class EntityStorageService {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "EntityStorageService";
-    /**
-     * The entity storage for items.
-     * @internal
-     */
-    _entityStorage;
-    /**
-     * Include the user identity when performing storage operations, this allow separation of data per user, default to false.
-     * @internal
-     */
-    _partitionPerUser;
-    /**
-     * Create a new instance of EntityStorageService.
-     * @param options The dependencies for the entity storage service.
-     */
-    constructor(options) {
-        Guards.string(this.CLASS_NAME, "options.entityStorageType", options.entityStorageType);
-        this._entityStorage = EntityStorageConnectorFactory.get(options.entityStorageType);
-        this._partitionPerUser = options.config?.partitionPerUser ?? false;
-    }
-    /**
-     * Set an entity.
-     * @param entity The entity to set.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns The id of the entity.
-     */
-    async set(entity, userIdentity) {
-        Guards.object(this.CLASS_NAME, "entity", entity);
-        const conditions = [];
-        if (this._partitionPerUser) {
-            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            conditions.push({
-                property: "userIdentity",
-                value: userIdentity
-            });
-            ObjectHelper.propertySet(entity, "userIdentity", userIdentity);
-        }
-        return this._entityStorage.set(entity, conditions);
-    }
-    /**
-     * 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.
-     * @returns The object if it can be found or undefined.
-     */
-    async get(id, secondaryIndex, userIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
-        return this.internalGet(id, secondaryIndex, userIdentity);
-    }
-    /**
-     * Remove the entity.
-     * @param id The id of the entity to remove.
-     * @param userIdentity The user identity to use with storage operations.
-     * @returns Nothing.
-     */
-    async remove(id, userIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
-        const conditions = [];
-        if (this._partitionPerUser) {
-            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            conditions.push({
-                property: "userIdentity",
-                value: userIdentity
-            });
-        }
-        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.
-     * @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) {
-        const finalConditions = {
-            conditions: [],
-            logicalOperator: LogicalOperator.And
-        };
-        if (this._partitionPerUser) {
-            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            finalConditions.conditions.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        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, "userIdentity");
-        }
-        return result;
-    }
-    /**
-     * 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.
-     * @returns The object if it can be found or throws.
-     * @internal
-     */
-    async internalGet(id, secondaryIndex, userIdentity) {
-        const conditions = [];
-        if (this._partitionPerUser) {
-            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
-            conditions.push({
-                property: "userIdentity",
-                comparison: ComparisonOperator.Equals,
-                value: userIdentity
-            });
-        }
-        if (Is.stringValue(secondaryIndex)) {
-            conditions.push({
-                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);
-            entity = results.entities[0];
-        }
-        if (Is.empty(entity)) {
-            throw new NotFoundError(this.CLASS_NAME, "entityNotFound", id);
-        }
-        ObjectHelper.propertyDelete(entity, "userIdentity");
-        return entity;
-    }
-}
-
-/**
- * These are dummy entry points for the entity storage service.
- * In reality your application would create its own entry points based on the
- * entity storage schema objects it wants to store, using a custom defaultBaseRoute.
- */
-const restEntryPoints = [
-    {
-        name: "entity-storage",
-        defaultBaseRoute: "entity-storage",
-        tags: tagsEntityStorage,
-        generateRoutes: generateRestRoutesEntityStorage
-    }
-];
-
-export { EntityStorageService, entityStorageGet, entityStorageList, entityStorageRemove, entityStorageSet, generateRestRoutesEntityStorage, restEntryPoints, tagsEntityStorage };

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

@@ -1,10 +0,0 @@
-/**
- * Configuration for the entity storage service.
- */
-export interface IEntityStorageConfig {
-    /**
-     * Include the user identity when performing storage operations, this allow separation of data per user.
-     * @default false
-     */
-    partitionPerUser?: boolean;
-}

package/docs/reference/interfaces/IEntityStorageConfig.md

@@ -1,17 +0,0 @@
-# Interface: IEntityStorageConfig
-
-Configuration for the entity storage service.
-
-## Properties
-
-### partitionPerUser?
-
-> `optional` **partitionPerUser**: `boolean`
-
-Include the user identity when performing storage operations, this allow separation of data per user.
-
-#### Default
-
-```ts
-false
-```