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

package/dist/esm/index.mjs

@@ -1,10 +1,10 @@
-import { Guards, ComponentFactory, Is, Converter, GeneralError, Validation, Urn, NotFoundError } from '@twin.org/core';
+import { StringHelper, Guards, ComponentFactory, Is, Converter, GeneralError, Validation, ObjectHelper, Urn, NotFoundError } from '@twin.org/core';
 import { HttpStatusCode, HeaderTypes, MimeTypes, MimeTypeHelper } from '@twin.org/web';
 import { BlobStorageConnectorFactory } from '@twin.org/blob-storage-models';
 import { JsonLdHelper } from '@twin.org/data-json-ld';
+import { ComparisonOperator, EntitySchemaHelper, LogicalOperator, property, entity, EntitySchemaFactory } from '@twin.org/entity';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { VaultConnectorFactory, VaultEncryptionType } from '@twin.org/vault-models';
-import { property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 
 /**
  * The source used when communicating about these routes.
@@ -23,13 +23,19 @@ const tagsBlobStorage = [
  * The REST routes for blob 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 Blob Storage.
+ * @param options.tagName Optional name to use in OpenAPI spec for tag.
  * @returns The generated routes.
  */
-function generateRestRoutesBlobStorage(baseRouteName, componentName) {
+function generateRestRoutesBlobStorage(baseRouteName, componentName, options) {
+    const typeName = options?.typeName ?? "Blob Storage";
+    const lowerName = typeName.toLowerCase();
+    const camelTypeName = StringHelper.camelCase(typeName);
     const blobStorageCreateRoute = {
-        operationId: "blobStorageCreate",
-        summary: "Create a blob in to storage",
-        tag: tagsBlobStorage[0].name,
+        operationId: `${camelTypeName}Create`,
+        summary: `Create an entry in ${lowerName}`,
+        tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "POST",
         path: `${baseRouteName}/`,
         handler: async (httpRequestContext, request) => blobStorageCreate(httpRequestContext, componentName, request),
@@ -37,7 +43,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageCreateRequest",
             examples: [
                 {
-                    id: "blobStorageCreateExample",
+                    id: `${camelTypeName}CreateRequestExample`,
                     request: {
                         body: {
                             blob: "VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZw==",
@@ -56,7 +62,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 type: "ICreatedResponse",
                 examples: [
                     {
-                        id: "blobStorageCreateResponseExample",
+                        id: `${camelTypeName}CreateResponseExample`,
                         response: {
                             statusCode: HttpStatusCode.created,
                             headers: {
@@ -69,9 +75,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageGetRoute = {
-        operationId: "blobStorageGet",
-        summary: "Get the blob metadata from storage",
-        tag: tagsBlobStorage[0].name,
+        operationId: `${camelTypeName}Get`,
+        summary: `Get the metadata for an item from ${lowerName}`,
+        tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "GET",
         path: `${baseRouteName}/:id`,
         handler: async (httpRequestContext, request) => blobStorageGet(httpRequestContext, componentName, request),
@@ -79,7 +85,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageGetRequest",
             examples: [
                 {
-                    id: "blobStorageGetRequestExample",
+                    id: `${camelTypeName}GetRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
@@ -96,7 +102,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 type: "IBlobStorageGetResponse",
                 examples: [
                     {
-                        id: "blobStorageGetResponseExample",
+                        id: `${camelTypeName}GetResponseExample`,
                         response: {
                             body: {
                                 metadata: {
@@ -116,9 +122,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageGetContentRoute = {
-        operationId: "blobStorageGetContent",
-        summary: "Get the blob from storage",
-        tag: tagsBlobStorage[0].name,
+        operationId: `${camelTypeName}GetContent`,
+        summary: `Get the content for an item in ${lowerName}`,
+        tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "GET",
         path: `${baseRouteName}/:id/content`,
         handler: async (httpRequestContext, request) => blobStorageGetContent(httpRequestContext, componentName, request),
@@ -126,7 +132,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageGetRequest",
             examples: [
                 {
-                    id: "blobStorageGetContentRequestExample",
+                    id: `${camelTypeName}GetContentRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
@@ -145,7 +151,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
                 mimeType: MimeTypes.OctetStream,
                 examples: [
                     {
-                        id: "blobStorageGetContentResponseExample",
+                        id: `${camelTypeName}GetContentResponseExample`,
                         description: `The content of the blob, which will be a specific mime type if one can be detected from the content (or set as mimeType in the metadata), or defaults to ${MimeTypes.OctetStream}.`,
                         response: {
                             body: new Uint8Array()
@@ -159,9 +165,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageUpdateRoute = {
-        operationId: "blobStorageUpdate",
-        summary: "Update a blob metadata in storage",
-        tag: tagsBlobStorage[0].name,
+        operationId: `${camelTypeName}Update`,
+        summary: `Update the metadata for an item in ${lowerName}`,
+        tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "PUT",
         path: `${baseRouteName}/:id`,
         handler: async (httpRequestContext, request) => blobStorageUpdate(httpRequestContext, componentName, request),
@@ -169,7 +175,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageUpdateRequest",
             examples: [
                 {
-                    id: "blobStorageUpdateExample",
+                    id: `${camelTypeName}UpdateRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
@@ -192,9 +198,9 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
         ]
     };
     const blobStorageRemoveRoute = {
-        operationId: "blobStorageRemove",
-        summary: "Remove the blob from storage",
-        tag: tagsBlobStorage[0].name,
+        operationId: `${camelTypeName}Remove`,
+        summary: `Remove an item from ${lowerName}`,
+        tag: options?.tagName ?? tagsBlobStorage[0].name,
         method: "DELETE",
         path: `${baseRouteName}/:id`,
         handler: async (httpRequestContext, request) => blobStorageRemove(httpRequestContext, componentName, request),
@@ -202,7 +208,7 @@ function generateRestRoutesBlobStorage(baseRouteName, componentName) {
             type: "IBlobStorageRemoveRequest",
             examples: [
                 {
-                    id: "blobStorageRemoveRequestExample",
+                    id: `${camelTypeName}RemoveRequestExample`,
                     request: {
                         pathParams: {
                             id: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70"
@@ -260,7 +266,7 @@ async function blobStorageGet(httpRequestContext, componentName, 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 result = await component.get(request.pathParams.id, request.query?.includeContent ?? false, httpRequestContext.nodeIdentity);
+    const result = await component.get(request.pathParams.id, request.query?.includeContent ?? false, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         body: result
     };
@@ -277,7 +283,7 @@ async function blobStorageGetContent(httpRequestContext, componentName, 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 result = await component.get(request.pathParams.id, true, httpRequestContext.nodeIdentity);
+    const result = await component.get(request.pathParams.id, true, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     const mimeType = result?.mimeType ?? MimeTypes.OctetStream;
     let filename = request.query?.filename;
     if (!Is.stringValue(filename)) {
@@ -304,7 +310,7 @@ async function blobStorageUpdate(httpRequestContext, componentName, 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.update(request.pathParams.id, request.body.mimeType, request.body.extension, request.body.metadata);
+    await component.update(request.pathParams.id, request.body.mimeType, request.body.extension, request.body.metadata, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.noContent
     };
@@ -321,7 +327,7 @@ async function blobStorageRemove(httpRequestContext, componentName, 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);
+    await component.remove(request.pathParams.id, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.noContent
     };
@@ -362,6 +368,16 @@ class BlobStorageService {
      * @internal
      */
     _vaultKeyId;
+    /**
+     * 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 BlobStorageService.
      * @param options The dependencies for the service.
@@ -380,6 +396,8 @@ class BlobStorageService {
         }
         this._defaultNamespace = options?.config?.defaultNamespace ?? names[0];
         this._vaultKeyId = options?.config?.vaultKeyId ?? "blob-storage";
+        this._includeNodeIdentity = options?.config?.includeNodeIdentity ?? true;
+        this._includeUserIdentity = options?.config?.includeUserIdentity ?? true;
     }
     /**
      * Create the blob with some metadata.
@@ -388,12 +406,16 @@ class BlobStorageService {
      * @param extension Extension for the blob, will be detected if left undefined.
      * @param metadata Data for the custom metadata as JSON-LD.
      * @param namespace The namespace to use for storing, defaults to component configured namespace.
-     * @param nodeIdentity The node identity which controls the vault key.
+     * @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 stored blob in urn format.
      */
-    async create(blob, mimeType, extension, metadata, namespace, nodeIdentity) {
+    async create(blob, mimeType, extension, metadata, namespace, userIdentity, nodeIdentity) {
         Guards.stringBase64(this.CLASS_NAME, "blob", blob);
-        if (this._vaultConnector) {
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         }
         try {
@@ -421,12 +443,23 @@ class BlobStorageService {
             }
             // Set the blob in the storage connector, which may now be encrypted
             const blobId = await blobStorageConnector.set(storeBlob);
-            await this._metadataEntityStorage.set({
+            // Now store the metadata in entity storage
+            const blobMetadata = {
                 id: blobId,
                 mimeType,
                 extension,
                 metadata
-            });
+            };
+            const conditions = [];
+            if (this._includeUserIdentity) {
+                ObjectHelper.propertySet(blobMetadata, "userIdentity", userIdentity);
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                ObjectHelper.propertySet(blobMetadata, "nodeIdentity", nodeIdentity);
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._metadataEntityStorage.set(blobMetadata, conditions);
             return blobId;
         }
         catch (error) {
@@ -437,18 +470,32 @@ class BlobStorageService {
      * Get the blob and metadata.
      * @param id The id of the blob to get in urn format.
      * @param includeContent Include the content, or just get the metadata.
-     * @param nodeIdentity The node identity which controls the vault key.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns The metadata and data for the blob if it can be found.
      * @throws Not found error if the blob cannot be found.
      */
-    async get(id, includeContent, nodeIdentity) {
+    async get(id, includeContent, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
-        if (this._vaultConnector && includeContent) {
+        const conditions = [];
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+            conditions.push({
+                property: "userIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: userIdentity
+            });
+        }
+        if (this._includeNodeIdentity || (Is.notEmpty(this._vaultConnector) && includeContent)) {
             Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+            conditions.push({
+                property: "nodeIdentity",
+                comparison: ComparisonOperator.Equals,
+                value: nodeIdentity
+            });
         }
         try {
-            // Get the metadata
-            const blobMetadata = await this._metadataEntityStorage.get(id);
+            const blobMetadata = await this.internalGet(id, userIdentity, nodeIdentity);
             let returnBlob;
             if (includeContent) {
                 const blobStorageConnector = this.getConnector(id);
@@ -478,11 +525,19 @@ class BlobStorageService {
      * @param mimeType Mime type for the blob, will be detected if left undefined.
      * @param extension Extension for the blob, will be detected if left undefined.
      * @param metadata Data for the custom metadata as JSON-LD.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns Nothing.
      * @throws Not found error if the blob cannot be found.
      */
-    async update(id, mimeType, extension, metadata) {
+    async update(id, mimeType, extension, metadata, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        }
         try {
             const blobMetadata = await this._metadataEntityStorage.get(id);
             if (Is.undefined(blobMetadata)) {
@@ -493,12 +548,23 @@ class BlobStorageService {
                 await JsonLdHelper.validate(metadata, validationFailures);
                 Validation.asValidationError(this.CLASS_NAME, "metadata", validationFailures);
             }
-            await this._metadataEntityStorage.set({
+            // Now store the metadata in entity storage
+            const updatedBlobMetadata = {
                 id: blobMetadata.id,
                 mimeType: mimeType ?? blobMetadata.mimeType,
                 extension: extension ?? blobMetadata.extension,
                 metadata: metadata ?? blobMetadata.metadata
-            });
+            };
+            const conditions = [];
+            if (this._includeUserIdentity) {
+                ObjectHelper.propertySet(updatedBlobMetadata, "userIdentity", userIdentity);
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                ObjectHelper.propertySet(updatedBlobMetadata, "nodeIdentity", nodeIdentity);
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._metadataEntityStorage.set(updatedBlobMetadata, conditions);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
@@ -507,17 +573,32 @@ class BlobStorageService {
     /**
      * Remove the blob.
      * @param id The id of the blob to remove in urn format.
+     * @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) {
+    async remove(id, userIdentity, nodeIdentity) {
         Urn.guard(this.CLASS_NAME, "id", id);
+        if (this._includeUserIdentity) {
+            Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        }
+        if (this._includeNodeIdentity || Is.notEmpty(this._vaultConnector)) {
+            Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        }
         try {
             const blobStorageConnector = this.getConnector(id);
+            const conditions = [];
+            if (this._includeUserIdentity) {
+                conditions.push({ property: "userIdentity", value: userIdentity });
+            }
+            if (this._includeNodeIdentity) {
+                conditions.push({ property: "nodeIdentity", value: nodeIdentity });
+            }
+            await this._metadataEntityStorage.remove(id, conditions);
             const removed = await blobStorageConnector.remove(id);
             if (!removed) {
                 throw new NotFoundError(this.CLASS_NAME, "blobNotFound", id);
             }
-            await this._metadataEntityStorage.remove(id);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "removeFailed", undefined, error);
@@ -539,6 +620,58 @@ class BlobStorageService {
         }
         return BlobStorageConnectorFactory.get(idUri.namespaceMethod());
     }
+    /**
+     * 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 throws.
+     * @internal
+     */
+    async internalGet(id, userIdentity, nodeIdentity) {
+        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
+            });
+        }
+        let entity;
+        if (conditions.length === 0) {
+            entity = await this._metadataEntityStorage.get(id);
+        }
+        else {
+            const schema = this._metadataEntityStorage.getSchema();
+            const primaryKey = EntitySchemaHelper.getPrimaryKey(schema);
+            conditions.unshift({
+                property: primaryKey.property,
+                comparison: ComparisonOperator.Equals,
+                value: id
+            });
+            const results = await this._metadataEntityStorage.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, "nodeIdentity");
+        ObjectHelper.propertyDelete(entity, "userIdentity");
+        return entity;
+    }
 }
 
 /**
@@ -561,6 +694,14 @@ let BlobMetadata = class BlobMetadata {
      * The metadata for the blob as JSON-LD.
      */
     metadata;
+    /**
+     * The user identity that created the blob.
+     */
+    userIdentity;
+    /**
+     * The node identity that created the blob.
+     */
+    nodeIdentity;
 };
 __decorate([
     property({ type: "string", isPrimary: true }),
@@ -578,14 +719,27 @@ __decorate([
     property({ type: "object", itemTypeRef: "IJsonLdNodeObject" }),
     __metadata("design:type", Object)
 ], BlobMetadata.prototype, "metadata", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], BlobMetadata.prototype, "userIdentity", void 0);
+__decorate([
+    property({ type: "string" }),
+    __metadata("design:type", String)
+], BlobMetadata.prototype, "nodeIdentity", void 0);
 BlobMetadata = __decorate([
     entity()
 ], BlobMetadata);
 
+/**
+ * These are dummy entry points for the blob storage service.
+ * In reality your application would create its own entry points based on the
+ * blob types it wants to store, using a custom defaultBaseRoute.
+ */
 const restEntryPoints = [
     {
-        name: "blobStorage",
-        defaultBaseRoute: "blob",
+        name: "blob-storage",
+        defaultBaseRoute: "blob-storage",
         tags: tagsBlobStorage,
         generateRoutes: generateRestRoutesBlobStorage
     }

package/dist/types/blobStorageRoutes.d.ts

@@ -8,9 +8,15 @@ export declare const tagsBlobStorage: ITag[];
  * The REST routes for blob 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 Blob Storage.
+ * @param options.tagName Optional name to use in OpenAPI spec for tag.
  * @returns The generated routes.
  */
-export declare function generateRestRoutesBlobStorage(baseRouteName: string, componentName: string): IRestRoute[];
+export declare function generateRestRoutesBlobStorage(baseRouteName: string, componentName: string, options?: {
+    typeName?: string;
+    tagName?: string;
+}): IRestRoute[];
 /**
  * Create a blob in storage.
  * @param httpRequestContext The request context for the API.

package/dist/types/blobStorageService.d.ts

@@ -32,19 +32,21 @@ export declare class BlobStorageService implements IBlobStorageComponent {
      * @param extension Extension for the blob, will be detected if left undefined.
      * @param metadata Data for the custom metadata as JSON-LD.
      * @param namespace The namespace to use for storing, defaults to component configured namespace.
-     * @param nodeIdentity The node identity which controls the vault key.
+     * @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 stored blob in urn format.
      */
-    create(blob: string, mimeType?: string, extension?: string, metadata?: IJsonLdNodeObject, namespace?: string, nodeIdentity?: string): Promise<string>;
+    create(blob: string, mimeType?: string, extension?: string, metadata?: IJsonLdNodeObject, namespace?: string, userIdentity?: string, nodeIdentity?: string): Promise<string>;
     /**
      * Get the blob and metadata.
      * @param id The id of the blob to get in urn format.
      * @param includeContent Include the content, or just get the metadata.
-     * @param nodeIdentity The node identity which controls the vault key.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns The metadata and data for the blob if it can be found.
      * @throws Not found error if the blob cannot be found.
      */
-    get(id: string, includeContent: boolean, nodeIdentity?: string): Promise<{
+    get(id: string, includeContent: boolean, userIdentity?: string, nodeIdentity?: string): Promise<{
         blob?: string;
         mimeType?: string;
         extension?: string;
@@ -56,14 +58,18 @@ export declare class BlobStorageService implements IBlobStorageComponent {
      * @param mimeType Mime type for the blob, will be detected if left undefined.
      * @param extension Extension for the blob, will be detected if left undefined.
      * @param metadata Data for the custom metadata as JSON-LD.
+     * @param userIdentity The user identity to use with storage operations.
+     * @param nodeIdentity The node identity to use with storage operations.
      * @returns Nothing.
      * @throws Not found error if the blob cannot be found.
      */
-    update(id: string, mimeType?: string, extension?: string, metadata?: IJsonLdNodeObject): Promise<void>;
+    update(id: string, mimeType?: string, extension?: string, metadata?: IJsonLdNodeObject, userIdentity?: string, nodeIdentity?: string): Promise<void>;
     /**
      * Remove the blob.
      * @param id The id of the blob to remove in urn format.
+     * @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): Promise<void>;
+    remove(id: string, userIdentity?: string, nodeIdentity?: string): Promise<void>;
 }

package/dist/types/entities/blobMetadata.d.ts

@@ -19,4 +19,12 @@ export declare class BlobMetadata {
      * The metadata for the blob as JSON-LD.
      */
     metadata?: IJsonLdNodeObject;
+    /**
+     * The user identity that created the blob.
+     */
+    userIdentity?: string;
+    /**
+     * The node identity that created the blob.
+     */
+    nodeIdentity?: string;
 }

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

@@ -12,4 +12,12 @@ export interface IBlobStorageServiceConfig {
      * Defaults to the first entry in the factory if not provided.
      */
     defaultNamespace?: string;
+    /**
+     * 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/restEntryPoints.d.ts

@@ -1,2 +1,7 @@
 import type { IRestRouteEntryPoint } from "@twin.org/api-models";
+/**
+ * These are dummy entry points for the blob storage service.
+ * In reality your application would create its own entry points based on the
+ * blob types it wants to store, using a custom defaultBaseRoute.
+ */
 export declare const restEntryPoints: IRestRouteEntryPoint[];

package/docs/changelog.md

@@ -1,5 +1,5 @@
 # @twin.org/blob-storage-service - Changelog
 
-## v0.0.1-next.8
+## v0.0.1-next.9
 
 - Initial Release