@twin.org/entity-storage-service 0.0.1-next.5

package/dist/esm/index.mjs

@@ -0,0 +1,433 @@
+import { HttpParameterHelper } from '@twin.org/api-models';
+import { StringHelper, Guards, ComponentFactory, Coerce, Is } from '@twin.org/core';
+import { HttpStatusCode } from '@twin.org/web';
+import { ComparisonOperator, LogicalOperator, 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"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    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"
+            }
+        ]
+    };
+    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, httpRequestContext.nodeIdentity);
+    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, httpRequestContext.nodeIdentity);
+    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, httpRequestContext.nodeIdentity);
+    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), HttpParameterHelper.objectFromString(request.query?.sortProperties), HttpParameterHelper.objectFromString(request.query?.properties), request.query?.cursor, Coerce.number(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    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 node identity when performing storage operations, defaults to true.
+     * @internal
+     */
+    _includeNodeIdentity;
+    /**
+     * Include the user identity when performing storage operations, defaults to true.
+     * @internal
+     */
+    _includeUserIdentity;
+    /**
+     * 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);
+        this._entityStorage = EntityStorageConnectorFactory.get(options.entityStorageType);
+        this._includeNodeIdentity = options.config?.includeNodeIdentity ?? true;
+        this._includeUserIdentity = options.config?.includeUserIdentity ?? true;
+    }
+    /**
+     * Set an entity.
+     * @param entity The entity to set.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns The id of the entity.
+     */
+    async set(entity, userIdentity, nodeIdentity) {
+        Guards.object(this.CLASS_NAME, "entity", entity);
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        }
+        entity.nodeIdentity = nodeIdentity;
+        entity.userIdentity = userIdentity;
+        return this._entityStorage.set(entity);
+    }
+    /**
+     * 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 The object if it can be found or undefined.
+     */
+    async get(id, secondaryIndex, 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",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
+        }
+        if (Is.stringValue(secondaryIndex)) {
+            conditions.push({
+                property: secondaryIndex,
+                comparison: ComparisonOperator.Equals,
+                value: id
+            });
+        }
+        if (conditions.length === 0) {
+            const entity = await this._entityStorage.get(id, secondaryIndex);
+            if (!Is.empty(entity)) {
+                delete entity.nodeIdentity;
+                delete entity.userIdentity;
+            }
+            return entity;
+        }
+        const results = await this._entityStorage.query({
+            conditions,
+            logicalOperator: LogicalOperator.And
+        }, undefined, undefined, undefined, 1);
+        const entity = results.entities[0];
+        delete entity.nodeIdentity;
+        delete entity.userIdentity;
+        return entity;
+    }
+    /**
+     * 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",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
+        }
+        if (conditions.length === 0) {
+            return this._entityStorage.remove(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];
+            const schema = this._entityStorage.getSchema();
+            const primaryKey = EntitySchemaHelper.getPrimaryKey(schema);
+            await this._entityStorage.remove(firstEntity[primaryKey.property]);
+        }
+    }
+    /**
+     * 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, sortProperties, properties, cursor, pageSize);
+        for (const entity of result.entities) {
+            delete entity.nodeIdentity;
+            delete entity.userIdentity;
+        }
+        return result;
+    }
+}
+
+/**
+ * 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/entityStorageRoutes.d.ts

@@ -0,0 +1,54 @@
+import { type IHttpRequestContext, type INoContentResponse, type IRestRoute, type ITag } from "@twin.org/api-models";
+import type { IEntityStorageGetRequest, IEntityStorageGetResponse, IEntityStorageListRequest, IEntityStorageListResponse, IEntityStorageRemoveRequest, IEntityStorageSetRequest } from "@twin.org/entity-storage-models";
+import type { IEntityStorageRoutesExamples } from "./models/IEntityStorageRoutesExamples";
+/**
+ * The tag to associate with the routes.
+ */
+export declare const tagsEntityStorage: ITag[];
+/**
+ * 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.
+ */
+export declare function generateRestRoutesEntityStorage(baseRouteName: string, componentName: string, options?: {
+    typeName?: string;
+    tagName?: string;
+    examples?: IEntityStorageRoutesExamples;
+}): IRestRoute[];
+/**
+ * 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.
+ */
+export declare function entityStorageSet(httpRequestContext: IHttpRequestContext, componentName: string, request: IEntityStorageSetRequest): Promise<INoContentResponse>;
+/**
+ * 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.
+ */
+export declare function entityStorageGet(httpRequestContext: IHttpRequestContext, componentName: string, request: IEntityStorageGetRequest): Promise<IEntityStorageGetResponse>;
+/**
+ * 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.
+ */
+export declare function entityStorageRemove(httpRequestContext: IHttpRequestContext, componentName: string, request: IEntityStorageRemoveRequest): Promise<INoContentResponse>;
+/**
+ * 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.
+ */
+export declare function entityStorageList(httpRequestContext: IHttpRequestContext, componentName: string, request: IEntityStorageListRequest): Promise<IEntityStorageListResponse>;

package/dist/types/entityStorageService.d.ts

@@ -0,0 +1,75 @@
+import { type SortDirection, type EntityCondition } from "@twin.org/entity";
+import { type IEntityStorageComponent } from "@twin.org/entity-storage-models";
+import type { IEntityStorageConfig } from "./models/IEntityStorageConfig";
+/**
+ * Class for performing entity service operations.
+ */
+export declare class EntityStorageService<T extends {
+    nodeIdentity?: string;
+    userIdentity?: string;
+} = any> implements IEntityStorageComponent<T> {
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * 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;
+    });
+    /**
+     * Set an entity.
+     * @param entity The entity to set.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
+     * @returns The id of the entity.
+     */
+    set(entity: T, userIdentity?: string, nodeIdentity?: string): Promise<void>;
+    /**
+     * 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 The object if it can be found or undefined.
+     */
+    get(id: string, secondaryIndex?: keyof T, userIdentity?: string, nodeIdentity?: string): Promise<T | undefined>;
+    /**
+     * 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.
+     */
+    remove(id: string, userIdentity?: string, nodeIdentity?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    query(conditions?: EntityCondition<T>, sortProperties?: {
+        property: keyof T;
+        sortDirection: 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.
+         */
+        entities: Partial<T>[];
+        /**
+         * An optional cursor, when defined can be used to call find to get more entities.
+         */
+        cursor?: string;
+    }>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./entityStorageRoutes";
+export * from "./entityStorageService";
+export * from "./models/IEntityStorageConfig";
+export * from "./models/IEntityStorageRoutesExamples";
+export * from "./restEntryPoints";

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

@@ -0,0 +1,13 @@
+/**
+ * Configuration for the entity storage service.
+ */
+export interface IEntityStorageConfig {
+    /**
+     * Include the node identity when performing storage operations, defaults to true.
+     */
+    includeNodeIdentity?: boolean;
+    /**
+     * Include the user identity when performing storage operations, defaults to true.
+     */
+    includeUserIdentity?: boolean;
+}

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

@@ -0,0 +1,33 @@
+import type { IRestRouteRequestExample, IRestRouteResponseExample } from "@twin.org/api-models";
+import type { IEntityStorageGetRequest, IEntityStorageGetResponse, IEntityStorageListRequest, IEntityStorageListResponse, IEntityStorageRemoveRequest, IEntityStorageSetRequest } from "@twin.org/entity-storage-models";
+/**
+ * Examples for the entity storage routes.
+ */
+export interface IEntityStorageRoutesExamples {
+    /**
+     * Examples for the set route.
+     */
+    set?: {
+        requestExamples: IRestRouteRequestExample<IEntityStorageSetRequest>[];
+    };
+    /**
+     * Examples for the get route.
+     */
+    get?: {
+        requestExamples: IRestRouteRequestExample<IEntityStorageGetRequest>[];
+        responseExamples: IRestRouteResponseExample<IEntityStorageGetResponse>[];
+    };
+    /**
+     * Examples for the remove route.
+     */
+    remove?: {
+        requestExamples: IRestRouteRequestExample<IEntityStorageRemoveRequest>[];
+    };
+    /**
+     * Examples for the list route.
+     */
+    list?: {
+        requestExamples: IRestRouteRequestExample<IEntityStorageListRequest>[];
+        responseExamples: IRestRouteResponseExample<IEntityStorageListResponse>[];
+    };
+}

package/dist/types/restEntryPoints.d.ts

@@ -0,0 +1,7 @@
+import type { IRestRouteEntryPoint } from "@twin.org/api-models";
+/**
+ * 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.
+ */
+export declare const restEntryPoints: IRestRouteEntryPoint[];

package/docs/changelog.md

@@ -0,0 +1,5 @@
+# @twin.org/entity-storage-service - Changelog
+
+## v0.0.1-next.5
+
+- Initial Release

package/docs/examples.md

@@ -0,0 +1 @@
+# @twin.org/entity-storage-service - Examples