@twin.org/synchronised-storage-service 0.0.1-next.8 → 0.0.3-next.1

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

@@ -1,8 +1,8 @@
-import type { ISyncChange, ISynchronisedEntity } from "@twin.org/synchronised-storage-models";
+import type { ISyncChange } from "@twin.org/synchronised-storage-models";
 /**
  * Class representing an entry for the sync snapshot.
  */
-export declare class SyncSnapshotEntry<T extends ISynchronisedEntity = ISynchronisedEntity> {
+export declare class SyncSnapshotEntry {
     /**
      * The id for the snapshot.
      */
@@ -42,5 +42,5 @@ export declare class SyncSnapshotEntry<T extends ISynchronisedEntity = ISynchron
     /**
      * The changes that were made in this snapshot, if this is a local snapshot.
      */
-    changes?: ISyncChange<T>[];
+    changes?: ISyncChange[];
 }

package/dist/types/helpers/blobStorageHelper.d.ts

@@ -8,16 +8,16 @@ export declare class BlobStorageHelper {
     /**
      * Runtime name for the class.
      */
-    readonly CLASS_NAME: string;
+    static readonly CLASS_NAME: string;
     /**
      * Create a new instance of BlobStorageHelper.
-     * @param loggingComponent The logging connector to use for logging.
+     * @param logging The logging component to use for logging.
      * @param vaultConnector The vault connector to use for for the encryption key.
      * @param blobStorageConnector The blob storage component to use.
      * @param blobStorageEncryptionKeyId The id of the vault key to use for encrypting/decrypting blobs.
      * @param isTrustedNode Is this a trusted node.
      */
-    constructor(loggingComponent: ILoggingComponent | undefined, vaultConnector: IVaultConnector, blobStorageConnector: IBlobStorageConnector, blobStorageEncryptionKeyId: string, isTrustedNode: boolean);
+    constructor(logging: ILoggingComponent | undefined, vaultConnector: IVaultConnector, blobStorageConnector: IBlobStorageConnector, blobStorageEncryptionKeyId: string, isTrustedNode: boolean);
     /**
      * Load a blob from storage.
      * @param blobId The id of the blob to apply.

package/dist/types/helpers/changeSetHelper.d.ts

@@ -1,81 +1,65 @@
 import type { IEventBusComponent } from "@twin.org/event-bus-models";
-import { type IIdentityConnector } from "@twin.org/identity-models";
 import type { ILoggingComponent } from "@twin.org/logging-models";
-import { type IProof } from "@twin.org/standards-w3c-did";
-import { type ISyncChangeSet, type ISynchronisedEntity, type SyncNodeIdentityMode } from "@twin.org/synchronised-storage-models";
-import type { BlobStorageHelper } from "./blobStorageHelper";
+import { type ISyncChangeSet, type SyncNodeIdMode } from "@twin.org/synchronised-storage-models";
+import type { BlobStorageHelper } from "./blobStorageHelper.js";
 /**
  * Class for performing change set operations.
  */
-export declare class ChangeSetHelper<T extends ISynchronisedEntity = ISynchronisedEntity> {
+export declare class ChangeSetHelper {
     /**
      * Runtime name for the class.
      */
-    readonly CLASS_NAME: string;
+    static readonly CLASS_NAME: string;
     /**
      * Create a new instance of ChangeSetHelper.
-     * @param loggingComponent The logging connector to use for logging.
+     * @param logging The logging component to use for logging.
      * @param eventBusComponent The event bus component to use for events.
-     * @param identityConnector The identity connector to use for signing/verifying changesets.
      * @param blobStorageHelper The blob storage component to use for remote sync states.
-     * @param decentralisedStorageMethodId The id of the identity method to use when signing/verifying changesets.
      */
-    constructor(loggingComponent: ILoggingComponent | undefined, eventBusComponent: IEventBusComponent, identityConnector: IIdentityConnector, blobStorageHelper: BlobStorageHelper, decentralisedStorageMethodId: string);
+    constructor(logging: ILoggingComponent | undefined, eventBusComponent: IEventBusComponent, blobStorageHelper: BlobStorageHelper);
     /**
      * Set the node identity to use for signing changesets.
-     * @param nodeIdentity The identity of the node that is performing the update.
+     * @param nodeId The identity of the node that is performing the update.
      */
-    setNodeIdentity(nodeIdentity: string): void;
+    setNodeId(nodeId: string): void;
     /**
-     * Get and verify a changeset.
+     * Get a changeset.
      * @param changeSetStorageId The id of the sync changeset to apply.
      * @returns The changeset if it was verified.
      */
-    getAndVerifyChangeset(changeSetStorageId: string): Promise<ISyncChangeSet<T> | undefined>;
+    getChangeset(changeSetStorageId: string): Promise<ISyncChangeSet | undefined>;
     /**
      * Apply a sync changeset.
      * @param changeSetStorageId The id of the sync changeset to apply.
      * @returns The changeset if it existed.
      */
-    getAndApplyChangeset(changeSetStorageId: string): Promise<ISyncChangeSet<T> | undefined>;
+    getAndApplyChangeset(changeSetStorageId: string): Promise<ISyncChangeSet | undefined>;
     /**
      * Apply a sync changeset.
      * @param syncChangeset The sync changeset to apply.
      * @returns Nothing.
      */
-    applyChangeset(syncChangeset: ISyncChangeSet<T>): Promise<void>;
+    applyChangeset(syncChangeset: ISyncChangeSet): Promise<void>;
     /**
      * Store the changeset.
      * @param syncChangeSet The sync change set to store.
      * @returns The id of the change set.
      */
     storeChangeSet(syncChangeSet: ISyncChangeSet): Promise<string>;
-    /**
-     * Verify the proof of a sync changeset.
-     * @param syncChangeset The sync changeset to verify.
-     * @returns True if the proof is valid, false otherwise.
-     */
-    verifyChangesetProof(syncChangeset: ISyncChangeSet): Promise<boolean>;
-    /**
-     * Create the proof of a sync change set.
-     * @param syncChangeset The sync changeset to create the proof for.
-     * @returns The proof.
-     */
-    createChangeSetProof(syncChangeset: ISyncChangeSet): Promise<IProof>;
     /**
      * Copy a change set.
      * @param syncChangeSet The sync changeset to copy.
      * @returns The id of the updated change set.
      */
-    copyChangeset(syncChangeSet: ISyncChangeSet<T>): Promise<{
-        syncChangeSet: ISyncChangeSet<T>;
+    copyChangeset(syncChangeSet: ISyncChangeSet): Promise<{
+        syncChangeSet: ISyncChangeSet;
         changeSetStorageId: string;
     } | undefined>;
     /**
      * Reset the storage for a given storage key.
      * @param storageKey The key of the storage to reset.
-     * @param resetMode The reset mode, this will use the nodeIdentity in the entities to determine which are local/remote.
+     * @param resetMode The reset mode, this will use the nodeId in the entities to determine which are local/remote.
      * @returns Nothing.
      */
-    reset(storageKey: string, resetMode: SyncNodeIdentityMode): Promise<void>;
+    reset(storageKey: string, resetMode: SyncNodeIdMode): Promise<void>;
 }

package/dist/types/helpers/localSyncStateHelper.d.ts

@@ -1,24 +1,24 @@
 import type { IEntityStorageConnector } from "@twin.org/entity-storage-models";
 import type { ILoggingComponent } from "@twin.org/logging-models";
-import { type ISynchronisedEntity, type SyncChangeOperation } from "@twin.org/synchronised-storage-models";
-import type { ChangeSetHelper } from "./changeSetHelper";
-import type { SyncSnapshotEntry } from "../entities/syncSnapshotEntry";
-import type { ISyncState } from "../models/ISyncState";
+import { type SyncChangeOperation } from "@twin.org/synchronised-storage-models";
+import type { ChangeSetHelper } from "./changeSetHelper.js";
+import type { SyncSnapshotEntry } from "../entities/syncSnapshotEntry.js";
+import type { ISyncState } from "../models/ISyncState.js";
 /**
  * Class for performing entity storage operations in decentralised storage.
  */
-export declare class LocalSyncStateHelper<T extends ISynchronisedEntity = ISynchronisedEntity> {
+export declare class LocalSyncStateHelper {
     /**
      * Runtime name for the class.
      */
-    readonly CLASS_NAME: string;
+    static readonly CLASS_NAME: string;
     /**
      * Create a new instance of LocalSyncStateHelper.
-     * @param loggingComponent The logging connector to use for logging.
+     * @param logging The logging component to use for logging.
      * @param snapshotEntryEntityStorage The storage connector for the sync snapshot entries.
      * @param changeSetHelper The change set helper to use for applying changesets.
      */
-    constructor(loggingComponent: ILoggingComponent | undefined, snapshotEntryEntityStorage: IEntityStorageConnector<SyncSnapshotEntry<T>>, changeSetHelper: ChangeSetHelper<T>);
+    constructor(logging: ILoggingComponent | undefined, snapshotEntryEntityStorage: IEntityStorageConnector<SyncSnapshotEntry>, changeSetHelper: ChangeSetHelper);
     /**
      * Add a new change to the local snapshot.
      * @param storageKey The storage key of the snapshot to add the change for.
@@ -33,19 +33,19 @@ export declare class LocalSyncStateHelper<T extends ISynchronisedEntity = ISynch
      * @param isLocal Whether to get the local snapshot or not.
      * @returns The local snapshot entry.
      */
-    getSnapshots(storageKey: string, isLocal: boolean): Promise<SyncSnapshotEntry<T>[]>;
+    getSnapshots(storageKey: string, isLocal: boolean): Promise<SyncSnapshotEntry[]>;
     /**
      * Set the current local snapshot with changes for this node.
      * @param localChangeSnapshot The local change snapshot to set.
      * @returns Nothing.
      */
-    setLocalChangeSnapshot(localChangeSnapshot: SyncSnapshotEntry<T>): Promise<void>;
+    setLocalChangeSnapshot(localChangeSnapshot: SyncSnapshotEntry): Promise<void>;
     /**
      * Get the current local snapshot with the changes for this node.
      * @param localChangeSnapshot The local change snapshot to remove.
      * @returns Nothing.
      */
-    removeLocalChangeSnapshot(localChangeSnapshot: SyncSnapshotEntry<T>): Promise<void>;
+    removeLocalChangeSnapshot(localChangeSnapshot: SyncSnapshotEntry): Promise<void>;
     /**
      * Apply a sync state to the local node.
      * @param storageKey The storage key of the snapshot to sync with.

package/dist/types/helpers/remoteSyncStateHelper.d.ts

@@ -1,21 +1,21 @@
 import type { IEventBusComponent } from "@twin.org/event-bus-models";
 import type { ILoggingComponent } from "@twin.org/logging-models";
-import { type ISyncChange, type ISyncChangeSet, type ISynchronisedEntity } from "@twin.org/synchronised-storage-models";
+import { type ISyncChange, type ISyncChangeSet } from "@twin.org/synchronised-storage-models";
 import type { IVerifiableStorageConnector } from "@twin.org/verifiable-storage-models";
-import type { BlobStorageHelper } from "./blobStorageHelper";
-import type { ChangeSetHelper } from "./changeSetHelper";
-import type { ISyncPointerStore } from "../models/ISyncPointerStore";
-import type { ISyncState } from "../models/ISyncState";
+import type { BlobStorageHelper } from "./blobStorageHelper.js";
+import type { ChangeSetHelper } from "./changeSetHelper.js";
+import type { ISyncPointerStore } from "../models/ISyncPointerStore.js";
+import type { ISyncState } from "../models/ISyncState.js";
 /**
  * Class for performing entity storage operations in decentralised storage.
  */
-export declare class RemoteSyncStateHelper<T extends ISynchronisedEntity = ISynchronisedEntity> {
+export declare class RemoteSyncStateHelper {
     /**
      * Runtime name for the class.
      */
-    readonly CLASS_NAME: string;
+    static readonly CLASS_NAME: string;
     /**
-     * Create a new instance of DecentralisedEntityStorageConnector.
+     * Create a new instance of RemoteSyncStateHelper.
      * @param loggingComponent The logging component to use for logging.
      * @param eventBusComponent The event bus component to use for events.
      * @param verifiableSyncPointerStorageConnector The verifiable storage connector to use for storing sync pointers.
@@ -24,12 +24,16 @@ export declare class RemoteSyncStateHelper<T extends ISynchronisedEntity = ISync
      * @param isTrustedNode Whether the node is trusted or not.
      * @param maxConsolidations The maximum number of consolidations to keep in storage.
      */
-    constructor(loggingComponent: ILoggingComponent | undefined, eventBusComponent: IEventBusComponent, verifiableSyncPointerStorageConnector: IVerifiableStorageConnector, blobStorageHelper: BlobStorageHelper, changeSetHelper: ChangeSetHelper<T>, isTrustedNode: boolean, maxConsolidations: number);
+    constructor(loggingComponent: ILoggingComponent | undefined, eventBusComponent: IEventBusComponent, verifiableSyncPointerStorageConnector: IVerifiableStorageConnector, blobStorageHelper: BlobStorageHelper, changeSetHelper: ChangeSetHelper, isTrustedNode: boolean, maxConsolidations: number);
     /**
      * Set the node identity to use for signing changesets.
-     * @param nodeIdentity The identity of the node that is performing the update.
+     * @param nodeId The identity of the node that is performing the update.
      */
-    setNodeIdentity(nodeIdentity: string): void;
+    setNodeId(nodeId: string): void;
+    /**
+     * Start the remote sync state helper.
+     */
+    start(): Promise<void>;
     /**
      * Set the synchronised storage key.
      * @param synchronisedStorageKey The synchronised storage key to use.
@@ -42,18 +46,18 @@ export declare class RemoteSyncStateHelper<T extends ISynchronisedEntity = ISync
      * @param completeCallback The callback to call when the changeset is created and stored.
      * @returns The storage id of the change set if created.
      */
-    buildChangeSet(storageKey: string, changes: ISyncChange<T>[], completeCallback: (syncChangeSet?: ISyncChangeSet<T>, id?: string) => Promise<void>): Promise<void>;
+    buildChangeSet(storageKey: string, changes: ISyncChange[], completeCallback: (syncChangeSet?: ISyncChangeSet, id?: string) => Promise<void>): Promise<void>;
     /**
      * Finalise the full details for the sync change set.
      * @param storageKey The storage key of the change set.
      * @param completeCallback The callback to call when the changeset is populated.
      * @returns Nothing.
      */
-    finaliseFullChanges(storageKey: string, completeCallback: (syncChangeSet?: ISyncChangeSet<T>, id?: string) => Promise<void>): Promise<void>;
+    finaliseFullChanges(storageKey: string, completeCallback: (syncChangeSet?: ISyncChangeSet, id?: string) => Promise<void>): Promise<void>;
     /**
      * Add a new changeset into the sync state.
      * @param storageKey The storage key of the change set to add.
-     * @param changeSetStorageId The id of the change set to add the the current state
+     * @param changeSetStorageId The id of the change set to add the current state
      * @returns Nothing.
      */
     addChangeSetToSyncState(storageKey: string, changeSetStorageId: string): Promise<void>;

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./entities/syncSnapshotEntry";
-export * from "./models/ISynchronisedStorageServiceConfig";
-export * from "./models/ISynchronisedStorageServiceConstructorOptions";
-export * from "./models/ISyncPointerStore";
-export * from "./models/ISyncSnapshot";
-export * from "./models/ISyncState";
-export * from "./restEntryPoints";
-export * from "./schema";
-export * from "./synchronisedStorageRoutes";
-export * from "./synchronisedStorageService";
+export * from "./entities/syncSnapshotEntry.js";
+export * from "./models/ISynchronisedStorageServiceConfig.js";
+export * from "./models/ISynchronisedStorageServiceConstructorOptions.js";
+export * from "./models/ISyncPointerStore.js";
+export * from "./models/ISyncSnapshot.js";
+export * from "./models/ISyncState.js";
+export * from "./restEntryPoints.js";
+export * from "./schema.js";
+export * from "./synchronisedStorageRoutes.js";
+export * from "./synchronisedStorageService.js";

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

@@ -1,4 +1,4 @@
-import type { ISyncSnapshot } from "./ISyncSnapshot";
+import type { ISyncSnapshot } from "./ISyncSnapshot.js";
 /**
  * The object definition for a sync state.
  */

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

@@ -2,28 +2,23 @@
  * Configuration for the Synchronised Storage Service.
  */
 export interface ISynchronisedStorageServiceConfig {
-    /**
-     * The id of the identity method to use when signing/verifying requests and changesets.
-     * @default synchronised-storage-assertion
-     */
-    synchronisedStorageMethodId?: string;
     /**
      * How often to check for entity updates in minutes.
      * @default 5
      */
     entityUpdateIntervalMinutes?: number;
     /**
-     * Interval to perform consolidation of changesets, only used if isTrustedNode is set.
+     * Interval to perform consolidation of changesets, only used if this is a trusted node.
      * @default 60
      */
     consolidationIntervalMinutes?: number;
     /**
-     * The number of entities to process in a single consolidation batch.
+     * The number of entities to process in a single consolidation batch, only used if this is a trusted node.
      * @default 1000
      */
     consolidationBatchSize?: number;
     /**
-     * The maximum number of consolidations to keep in storage.
+     * The maximum number of consolidations to keep in storage, only used if this is a trusted node.
      * @default 5
      */
     maxConsolidations?: number;

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

@@ -1,4 +1,4 @@
-import type { ISynchronisedStorageServiceConfig } from "./ISynchronisedStorageServiceConfig";
+import type { ISynchronisedStorageServiceConfig } from "./ISynchronisedStorageServiceConfig.js";
 /**
  * Options for the Synchronised Storage Service constructor.
  */
@@ -30,16 +30,17 @@ export interface ISynchronisedStorageServiceConstructorOptions {
      * @default verifiable-storage
      */
     verifiableStorageConnectorType?: string;
-    /**
-     * The identity connector.
-     * @default identity
-     */
-    identityConnectorType?: string;
     /**
      * The task scheduler component.
      * @default task-scheduler
      */
     taskSchedulerComponentType?: string;
+    /**
+     * The rights management enforcement component to use for verifying untrusted node access.
+     * Only required on a trusted node to enforce access control.
+     * @default policy-enforcement-point
+     */
+    policyEnforcementPointComponentType?: string;
     /**
      * The synchronised entity storage component type to use if this node is not trusted.
      * If this is set, this node uses it as the trusted node to store changesets.

package/dist/types/synchronisedStorageRoutes.d.ts

@@ -1,5 +1,5 @@
 import type { IHttpRequestContext, INoContentResponse, IRestRoute, ITag } from "@twin.org/api-models";
-import type { ISyncChangeSetRequest, ISyncDecryptionKeyRequest, ISyncDecryptionKeyResponse } from "@twin.org/synchronised-storage-models";
+import { type ISyncChangeSetRequest, type ISyncDecryptionKeyRequest, type ISyncDecryptionKeyResponse } from "@twin.org/synchronised-storage-models";
 /**
  * The tag to associate with the routes.
  */

package/dist/types/synchronisedStorageService.d.ts

@@ -1,51 +1,48 @@
-import { type IProof } from "@twin.org/standards-w3c-did";
-import { type ISyncChangeSet, type ISynchronisedEntity, type ISynchronisedStorageComponent } from "@twin.org/synchronised-storage-models";
-import type { ISynchronisedStorageServiceConstructorOptions } from "./models/ISynchronisedStorageServiceConstructorOptions";
+import { type IIdentityAuthenticationActionRequest } from "@twin.org/identity-authentication";
+import { type ISyncChangeSet, type ISynchronisedStorageComponent } from "@twin.org/synchronised-storage-models";
+import type { ISynchronisedStorageServiceConstructorOptions } from "./models/ISynchronisedStorageServiceConstructorOptions.js";
 /**
  * Class for performing synchronised storage operations.
  */
-export declare class SynchronisedStorageService<T extends ISynchronisedEntity = ISynchronisedEntity> implements ISynchronisedStorageComponent {
+export declare class SynchronisedStorageService implements ISynchronisedStorageComponent {
     /**
      * Runtime name for the class.
      */
-    readonly CLASS_NAME: string;
+    static readonly CLASS_NAME: string;
     /**
      * Create a new instance of SynchronisedStorageService.
      * @param options The options for the service.
      */
     constructor(options: ISynchronisedStorageServiceConstructorOptions);
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
     /**
      * The component needs to be started when the node is initialized.
-     * @param nodeIdentity The identity of the node starting the component.
-     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
-     * @param componentState A persistent state which can be modified by the method.
+     * @param nodeLoggingComponentType The node logging component type.
      * @returns Nothing.
      */
-    start(nodeIdentity: string, nodeLoggingConnectorType: string | undefined, componentState?: {
-        [id: string]: unknown;
-    }): Promise<void>;
+    start(nodeLoggingComponentType?: string): Promise<void>;
     /**
      * The component needs to be stopped when the node is closed.
-     * @param nodeIdentity The identity of the node stopping the component.
-     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
-     * @param componentState A persistent state which can be modified by the method.
+     * @param nodeLoggingComponentType The node logging component type.
      * @returns Nothing.
      */
-    stop(nodeIdentity: string, nodeLoggingConnectorType: string | undefined, componentState?: {
-        [id: string]: unknown;
-    }): Promise<void>;
+    stop(nodeLoggingComponentType?: string): Promise<void>;
     /**
      * Get the decryption key for the synchronised storage.
      * This is used to decrypt the data stored in the synchronised storage.
-     * @param nodeIdentity The identity of the node requesting the decryption key.
-     * @param proof The proof of the request so we know the request is from the specified node.
+     * @param actionRequest The action request used in the verifiable credential.
      * @returns The decryption key.
      */
-    getDecryptionKey(nodeIdentity: string, proof: IProof): Promise<string>;
+    getDecryptionKey(actionRequest: IIdentityAuthenticationActionRequest): Promise<string>;
     /**
      * Synchronise a set of changes from an untrusted node, assumes this is a trusted node.
      * @param syncChangeSet The change set to synchronise.
+     * @param actionRequest The action request used in the verifiable credential.
      * @returns Nothing.
      */
-    syncChangeSet(syncChangeSet: ISyncChangeSet<T>): Promise<void>;
+    syncChangeSet(syncChangeSet: ISyncChangeSet, actionRequest: IIdentityAuthenticationActionRequest): Promise<void>;
 }