Updated BaseMessage in preparation for external Store interface implementations (#418)

* Removed Record specific properties from `BaseMessage`
* Renamed `BaseMessage` to `GenericMessage` - Makes more sense from the perspective of the store implementor, as they don't care about inheritance/extension
* Opportunistic rename of `Reply" types

Author: thehenrytsai

README.md

@@ -23,9 +23,11 @@ For advanced users wishing to use this repo directly:
 npm install @tbd54566975/dwn-sdk-js
 ```
 
-Additional steps needed for some environments.
+## Additional Steps
 
-Node.js <= 18
+This package has dependency on [`@noble/ed25519`](https://github.com/paulmillr/noble-ed25519#usage) and [`@noble/secp256k1`](https://github.com/paulmillr/noble-secp256k1#usage) v2, additional steps are needed for some environments:
+
+- Node.js <= 18
 
 ```js
 // node.js 18 and earlier,  needs globalThis.crypto polyfill
@@ -34,7 +36,7 @@ import { webcrypto } from "node:crypto";
 if (!globalThis.crypto) globalThis.crypto = webcrypto;
 ```
 
-React Native:
+- React Native:
 
 ```js
 // If you're on react native. React Native needs crypto.getRandomValues polyfill and sha512

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@tbd54566975/dwn-sdk-js",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "description": "A reference implementation of https://identity.foundation/decentralized-web-node/spec/",
   "repository": {
     "type": "git",

package.json

@@ -1,7 +1,7 @@
-import type { BaseMessage } from '../types/message-types.js';
 import type { CID } from 'multiformats';
 import type { DidResolver } from '../did/did-resolver.js';
 import type { GeneralJws } from '../types/jws-types.js';
+import type { GenericMessage } from '../types/message-types.js';
 import type { Message } from './message.js';
 
 import { Cid } from '../utils/cid.js';
@@ -22,7 +22,7 @@ type AuthorizationPayloadConstraints = {
  */
 export async function canonicalAuth(
   tenant: string,
-  incomingMessage: Message<BaseMessage>,
+  incomingMessage: Message<GenericMessage>,
   didResolver: DidResolver
 ): Promise<void> {
   await authenticate(incomingMessage.message.authorization, didResolver);
@@ -36,7 +36,7 @@ export async function canonicalAuth(
  * @returns the parsed JSON payload object if validation succeeds.
  */
 export async function validateAuthorizationIntegrity(
-  message: BaseMessage,
+  message: GenericMessage,
   authorizationPayloadConstraints?: AuthorizationPayloadConstraints
 ): Promise<{ descriptorCid: CID, [key: string]: any }> {
   if (message.authorization === undefined) {
@@ -94,7 +94,7 @@ export async function authenticate(jws: GeneralJws | undefined, didResolver: Did
  * Authorizes the incoming message.
  * @throws {Error} if fails authentication
  */
-export async function authorize(tenant: string, incomingMessage: Message<BaseMessage>): Promise<void> {
+export async function authorize(tenant: string, incomingMessage: Message<GenericMessage>): Promise<void> {
   // if author is the same as the target tenant, we can directly grant access
   if (incomingMessage.author === tenant) {
     return;

src/core/auth.ts

@@ -6,21 +6,21 @@ type Status = {
   detail: string
 };
 
-export type BaseMessageReply = {
+export type GenericMessageReply = {
   status: Status;
 };
 
-export function messageReplyFromError(e: unknown, code: number): BaseMessageReply {
+export function messageReplyFromError(e: unknown, code: number): GenericMessageReply {
 
   const detail = e instanceof Error ? e.message : 'Error';
 
   return { status: { code, detail } };
 }
 
 /**
- * Catch-all message reply type. It is recommended to use BaseMessageReply or a message-specific reply type whereever possible.
+ * Catch-all message reply type. It is recommended to use GenericMessageReply or a message-specific reply type whereever possible.
  */
-export type GenericMessageReply = BaseMessageReply & {
+export type UnionMessageReply = GenericMessageReply & {
   /**
    * Resulting message entries or events returned from the invocation of the corresponding message.
    * e.g. the resulting messages from a RecordsQuery

src/core/message-reply.ts

@@ -1,6 +1,6 @@
 import type { GeneralJws } from '../types/jws-types.js';
 import type { SignatureInput } from '../types/jws-types.js';
-import type { BaseDecodedAuthorizationPayload, BaseMessage, Descriptor, TimestampedMessage } from '../types/message-types.js';
+import type { BaseDecodedAuthorizationPayload, Descriptor, GenericMessage, TimestampedMessage } from '../types/message-types.js';
 
 import { Cid } from '../utils/cid.js';
 import { GeneralJwsSigner } from '../jose/jws/general/signer.js';
@@ -30,7 +30,7 @@ export enum DwnMethodName {
   Delete = 'Delete'
 }
 
-export abstract class Message<M extends BaseMessage> {
+export abstract class Message<M extends GenericMessage> {
   readonly message: M;
   readonly authorizationPayload: any;
 
@@ -42,14 +42,14 @@ export abstract class Message<M extends BaseMessage> {
 
     if (message.authorization !== undefined) {
       this.authorizationPayload = Jws.decodePlainObjectPayload(message.authorization);
-      this.author = Message.getAuthor(message as BaseMessage);
+      this.author = Message.getAuthor(message as GenericMessage);
     }
   }
 
   /**
    * Called by `JSON.stringify(...)` automatically.
    */
-  toJSON(): BaseMessage {
+  toJSON(): GenericMessage {
     return this.message;
   }
 
@@ -69,7 +69,7 @@ export abstract class Message<M extends BaseMessage> {
   /**
    * Gets the DID of the author of the given message, returned `undefined` if message is not signed.
    */
-  public static getAuthor(message: BaseMessage): string | undefined {
+  public static getAuthor(message: GenericMessage): string | undefined {
     if (message.authorization === undefined) {
       return undefined;
     }
@@ -81,7 +81,7 @@ export abstract class Message<M extends BaseMessage> {
   /**
    * Gets the CID of the given message.
    */
-  public static async getCid(message: BaseMessage): Promise<string> {
+  public static async getCid(message: GenericMessage): Promise<string> {
     // NOTE: we wrap the `computeCid()` here in case that
     // the message will contain properties that should not be part of the CID computation
     // and we need to strip them out (like `encodedData` that we historically had for a long time),
@@ -94,7 +94,7 @@ export abstract class Message<M extends BaseMessage> {
    * Compares message CID in lexicographical order according to the spec.
    * @returns 1 if `a` is larger than `b`; -1 if `a` is smaller/older than `b`; 0 otherwise (same message)
    */
-  public static async compareCid(a: BaseMessage, b: BaseMessage): Promise<number> {
+  public static async compareCid(a: GenericMessage, b: GenericMessage): Promise<number> {
     // the < and > operators compare strings in lexicographical order
     const cidA = await Message.getCid(a);
     const cidB = await Message.getCid(b);
@@ -105,16 +105,16 @@ export abstract class Message<M extends BaseMessage> {
    * Compares the CID of two messages.
    * @returns `true` if `a` is newer than `b`; `false` otherwise
    */
-  public static async isCidLarger(a: BaseMessage, b: BaseMessage): Promise<boolean> {
+  public static async isCidLarger(a: GenericMessage, b: GenericMessage): Promise<boolean> {
     const aIsLarger = (await Message.compareCid(a, b) > 0);
     return aIsLarger;
   }
 
   /**
    * @returns message with the largest CID in the array using lexicographical compare. `undefined` if given array is empty.
    */
-  public static async getMessageWithLargestCid(messages: BaseMessage[]): Promise<BaseMessage | undefined> {
-    let currentNewestMessage: BaseMessage | undefined = undefined;
+  public static async getMessageWithLargestCid(messages: GenericMessage[]): Promise<GenericMessage | undefined> {
+    let currentNewestMessage: GenericMessage | undefined = undefined;
     for (const message of messages) {
       if (currentNewestMessage === undefined || await Message.isCidLarger(message, currentNewestMessage)) {
         currentNewestMessage = message;

src/core/message.ts

@@ -1,12 +1,12 @@
-import type { BaseMessage } from './types/message-types.js';
 import type { DataStore } from './types/data-store.js';
 import type { EventLog } from './types/event-log.js';
+import type { GenericMessage } from './types/message-types.js';
 import type { MessageStore } from './types/message-store.js';
 import type { MethodHandler } from './types/method-handler.js';
 import type { Readable } from 'readable-stream';
 import type { RecordsWriteHandlerOptions } from './handlers/records-write.js';
 import type { TenantGate } from './core/tenant-gate.js';
-import type { BaseMessageReply , GenericMessageReply } from './core/message-reply.js';
+import type { GenericMessageReply, UnionMessageReply } from './core/message-reply.js';
 import type { MessagesGetMessage, MessagesGetReply } from './types/messages-types.js';
 import type { RecordsQueryMessage, RecordsQueryReply, RecordsReadMessage, RecordsReadReply, RecordsWriteMessage } from './types/records-types.js';
 
@@ -94,7 +94,7 @@ export class Dwn {
    * Processes the given DWN message and returns with a reply.
    * @param tenant The tenant DID to route the given message to.
    */
-  public async processMessage(tenant: string, rawMessage: any, dataStream?: Readable): Promise<GenericMessageReply> {
+  public async processMessage(tenant: string, rawMessage: any, dataStream?: Readable): Promise<UnionMessageReply> {
     const errorMessageReply = await this.validateTenant(tenant) ?? await this.validateMessageIntegrity(rawMessage);
     if (errorMessageReply !== undefined) {
       return errorMessageReply;
@@ -103,7 +103,7 @@ export class Dwn {
     const handlerKey = rawMessage.descriptor.interface + rawMessage.descriptor.method;
     const methodHandlerReply = await this.methodHandlers[handlerKey].handle({
       tenant,
-      message: rawMessage as BaseMessage,
+      message: rawMessage as GenericMessage,
       dataStream
     });
 
@@ -158,7 +158,7 @@ export class Dwn {
   /**
    * Privileged method for writing a pruned initial `RecordsWrite` to a DWN without needing to supply associated data.
    */
-  public async synchronizePrunedInitialRecordsWrite(tenant: string, message: RecordsWriteMessage): Promise<BaseMessageReply> {
+  public async synchronizePrunedInitialRecordsWrite(tenant: string, message: RecordsWriteMessage): Promise<GenericMessageReply> {
     const errorMessageReply =
       await this.validateTenant(tenant) ??
       await this.validateMessageIntegrity(message, DwnInterfaceName.Records, DwnMethodName.Write);
@@ -178,9 +178,9 @@ export class Dwn {
   /**
    * Checks tenant gate to see if tenant is allowed.
    * @param tenant The tenant DID to route the given message to.
-   * @returns BaseMessageReply if the message has an integrity error, otherwise undefined.
+   * @returns GenericMessageReply if the message has an integrity error, otherwise undefined.
    */
-  public async validateTenant(tenant: string): Promise<BaseMessageReply | undefined> {
+  public async validateTenant(tenant: string): Promise<GenericMessageReply | undefined> {
     const isTenant = await this.tenantGate.isTenant(tenant);
     if (!isTenant) {
       return {
@@ -195,13 +195,13 @@ export class Dwn {
    * @param dwnMessageInterface The interface of DWN message.
    * @param dwnMessageMethod The interface of DWN message.
 
-   * @returns BaseMessageReply if the message has an integrity error, otherwise undefined.
+   * @returns GenericMessageReply if the message has an integrity error, otherwise undefined.
    */
   public async validateMessageIntegrity(
     rawMessage: any,
     expectedInterface?: DwnInterfaceName,
     expectedMethod?: DwnMethodName,
-  ): Promise<BaseMessageReply | undefined> {
+  ): Promise<GenericMessageReply | undefined> {
     // Verify interface and method
     const dwnInterface = rawMessage?.descriptor?.interface;
     const dwnMethod = rawMessage?.descriptor?.method;

src/dwn.ts

@@ -2,6 +2,7 @@ import type { DataStore } from '../types/data-store.js';
 import type { DidResolver } from '../did/did-resolver.js';
 import type { MessageStore } from '../types/message-store.js';
 import type { MethodHandler } from '../types/method-handler.js';
+import type { RecordsWriteMessage } from '../types/records-types.js';
 import type { MessagesGetMessage, MessagesGetReply, MessagesGetReplyEntry } from '../types/messages-types.js';
 
 import { DataStream } from '../utils/data-stream.js';
@@ -66,8 +67,10 @@ export class MessagesGetHandler implements MethodHandler {
         continue;
       }
 
-      const dataCid = message.descriptor.dataCid;
-      const dataSize = message.descriptor.dataSize;
+      // RecordsWrite specific handling
+      const recordsWrite = message as RecordsWriteMessage;
+      const dataCid = recordsWrite.descriptor.dataCid;
+      const dataSize = recordsWrite.descriptor.dataSize;
 
       if (dataCid !== undefined && dataSize! <= DwnConstant.maxDataSizeAllowedToBeEncoded) {
         const messageCid = await Message.getCid(message);

src/handlers/messages-get.ts

@@ -1,4 +1,4 @@
-import type { BaseMessageReply } from '../core/message-reply.js';
+import type { GenericMessageReply } from '../core/message-reply.js';
 import type { MethodHandler } from '../types/method-handler.js';
 import type { PermissionsGrantMessage } from '../types/permissions-types.js';
 import type { DidResolver, EventLog, MessageStore } from '../index.js';
@@ -14,7 +14,7 @@ export class PermissionsGrantHandler implements MethodHandler {
   public async handle({
     tenant,
     message
-  }: { tenant: string, message: PermissionsGrantMessage }): Promise<BaseMessageReply> {
+  }: { tenant: string, message: PermissionsGrantMessage }): Promise<GenericMessageReply> {
     let permissionsGrant: PermissionsGrant;
     try {
       permissionsGrant = await PermissionsGrant.parse(message);
@@ -29,7 +29,7 @@ export class PermissionsGrantHandler implements MethodHandler {
       return messageReplyFromError(e, 401);
     }
 
-    const { dataSize, scope, conditions, ...propertiesToIndex } = message.descriptor;
+    const { scope, conditions, ...propertiesToIndex } = message.descriptor;
     const indexes: { [key: string]: string } = {
       author: permissionsGrant.author!,
       ...propertiesToIndex,

src/handlers/permissions-grant.ts

@@ -1,4 +1,4 @@
-import type { BaseMessageReply } from '../core/message-reply.js';
+import type { GenericMessageReply } from '../core/message-reply.js';
 import type { MethodHandler } from '../types/method-handler.js';
 import type { PermissionsRequestMessage } from '../types/permissions-types.js';
 import type { DidResolver, EventLog, MessageStore } from '../index.js';
@@ -15,7 +15,7 @@ export class PermissionsRequestHandler implements MethodHandler {
   public async handle({
     tenant,
     message
-  }: { tenant: string, message: PermissionsRequestMessage }): Promise<BaseMessageReply> {
+  }: { tenant: string, message: PermissionsRequestMessage }): Promise<GenericMessageReply> {
     let permissionsRequest: PermissionsRequest;
     try {
       permissionsRequest = await PermissionsRequest.parse(message);
@@ -31,7 +31,7 @@ export class PermissionsRequestHandler implements MethodHandler {
     }
 
     // store message
-    const { dataSize, scope, conditions, ...propertiesToIndex } = message.descriptor;
+    const { scope, conditions, ...propertiesToIndex } = message.descriptor;
     const indexes: { [key: string]: string } = {
       ...propertiesToIndex,
       author: permissionsRequest.author!,