@abaxxtech/id 0.0.0

package/src/handlers/permissions-revoke.ts

@@ -0,0 +1,121 @@
+import type { DidResolver } from '../did/did-resolver.js';
+import type { EventLog } from '../types/event-log.js';
+import type { GenericMessageReply } from '../core/message-reply.js';
+import type { MessageStore } from '../types/message-store.js';
+import type { MethodHandler } from '../types/method-handler.js';
+import type { PermissionsGrantMessage, PermissionsRevokeMessage } from '../types/permissions-types.js';
+
+import { authenticate } from '../core/auth.js';
+import { Message } from '../core/message.js';
+import { messageReplyFromError } from '../core/message-reply.js';
+import { PermissionsRevoke } from '../interfaces/permissions-revoke.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export class PermissionsRevokeHandler implements MethodHandler {
+  constructor(private didResolver: DidResolver, private messageStore: MessageStore, private eventLog: EventLog) { }
+
+  public async handle({
+    tenant,
+    message
+  }: { tenant: string, message: PermissionsRevokeMessage }): Promise<GenericMessageReply> {
+    let permissionsRevoke: PermissionsRevoke;
+    try {
+      permissionsRevoke = await PermissionsRevoke.parse(message);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
+    }
+
+
+    // Authentication
+    try {
+      await authenticate(message.authorization, this.didResolver);
+    } catch (e) {
+      return messageReplyFromError(e, 401);
+    }
+
+    // Authorization
+    const permissionsGrantId = message.descriptor.permissionsGrantId;
+    const permissionsGrantMessage = await this.messageStore.get(
+      tenant,
+      permissionsGrantId
+    ) as PermissionsGrantMessage | undefined;
+
+    if (permissionsGrantMessage === undefined) {
+      return {
+        status: {
+          code   : 400,
+          detail : `Could not find PermissionsGrant with CID ${permissionsGrantId}`
+        }
+      };
+    }
+
+    try {
+      await permissionsRevoke.authorize(permissionsGrantMessage);
+    } catch (e) {
+      return messageReplyFromError(e, 401);
+    }
+
+    // Revoke must have `dateCreated` after that of the grant
+    if (message.descriptor.messageTimestamp < permissionsGrantMessage.descriptor.messageTimestamp) {
+      return {
+        status: { code: 400, detail: 'PermissionsRevoke has earlier date than associated PermissionsGrant' }
+      };
+    }
+
+    // query for previous revocations of this grant
+    const query = {
+      interface : DwnInterfaceName.Permissions,
+      method    : DwnMethodName.Revoke,
+      permissionsGrantId,
+    };
+    const { messages: existingRevokesForGrant } = await this.messageStore.query(tenant, [ query ]);
+
+    // Conflict 409 if the grant already has an older revoke
+    const oldestExistingRevoke = await Message.getOldestMessage(existingRevokesForGrant);
+    if (oldestExistingRevoke !== undefined) {
+      if (await Message.isOlder(message, oldestExistingRevoke)) {
+        // incoming revoke is older then existing revoke, proceed
+      } else {
+        // existing revoke is older then incoming revoke, ignore incoming
+        return {
+          status: { code: 409, detail: 'Conflict' }
+        };
+      }
+    }
+
+    // Store incoming PermissionsRevoke
+    const indexes: { [key: string]: string } = {
+      interface          : DwnInterfaceName.Permissions,
+      method             : DwnMethodName.Revoke,
+      permissionsGrantId : message.descriptor.permissionsGrantId,
+    };
+    await this.messageStore.put(tenant, message, indexes);
+    await this.eventLog.append(tenant, await Message.getCid(message));
+
+    // Delete existing revokes which are all newer than the incoming message
+    const removedRevokeCids: string[] = [];
+    for (const existingRevoke of existingRevokesForGrant) {
+      const existingRevokeCid = await Message.getCid(existingRevoke);
+      await this.messageStore.delete(tenant, existingRevokeCid);
+      removedRevokeCids.push(existingRevokeCid);
+    }
+    await this.eventLog.deleteEventsByCid(tenant, removedRevokeCids);
+
+    // Delete grant-authorized messages with timestamp after revocation
+    const grantAuthdMessagesQuery = {
+      permissionsGrantId,
+      dateCreated: { gte: message.descriptor.messageTimestamp },
+    };
+    const { messages: grantAuthdMessagesAfterRevoke } = await this.messageStore.query(tenant, [ grantAuthdMessagesQuery ]);
+    const grantAuthdMessageCidsAfterRevoke: string[] = [];
+    for (const grantAuthdMessage of grantAuthdMessagesAfterRevoke) {
+      const messageCid = await Message.getCid(grantAuthdMessage);
+      await this.messageStore.delete(tenant, messageCid);
+    }
+    this.eventLog.deleteEventsByCid(tenant, grantAuthdMessageCidsAfterRevoke);
+
+    return {
+      status: { code: 202, detail: 'Accepted' }
+    };
+  }
+}

package/src/handlers/protocols-configure.ts

@@ -0,0 +1,104 @@
+import type { DataStore } from '../types/data-store.js';
+import type { DidResolver } from '../did/did-resolver.js';
+import type { EventLog } from '../types/event-log.js';
+import type { GenericMessageReply } from '../core/message-reply.js';
+import type { MessageStore } from '../types//message-store.js';
+import type { MethodHandler } from '../types/method-handler.js';
+import type { ProtocolsConfigureMessage } from '../types/protocols-types.js';
+
+import { Message } from '../core/message.js';
+import { messageReplyFromError } from '../core/message-reply.js';
+import { ProtocolsConfigure } from '../interfaces/protocols-configure.js';
+import { authenticate, authorize } from '../core/auth.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export class ProtocolsConfigureHandler implements MethodHandler {
+
+  constructor(private didResolver: DidResolver, private messageStore: MessageStore, private dataStore: DataStore, private eventLog: EventLog) { }
+
+  public async handle({
+    tenant,
+    message,
+    dataStream: _dataStream
+  }: {tenant: string, message: ProtocolsConfigureMessage, dataStream: _Readable.Readable}): Promise<GenericMessageReply> {
+
+    let protocolsConfigure: ProtocolsConfigure;
+    try {
+      protocolsConfigure = await ProtocolsConfigure.parse(message);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
+    }
+
+    // authentication & authorization
+    try {
+      await authenticate(message.authorization, this.didResolver);
+      await authorize(tenant, protocolsConfigure);
+    } catch (e) {
+      return messageReplyFromError(e, 401);
+    }
+
+    // attempt to get existing protocol
+    const query = {
+      interface : DwnInterfaceName.Protocols,
+      method    : DwnMethodName.Configure,
+      protocol  : message.descriptor.definition.protocol
+    };
+    const { messages: existingMessages } = await this.messageStore.query(tenant, [ query ]);
+
+    // find newest message, and if the incoming message is the newest
+    let newestMessage = await Message.getNewestMessage(existingMessages);
+    let incomingMessageIsNewest = false;
+    if (newestMessage === undefined || await Message.isNewer(message, newestMessage)) {
+      incomingMessageIsNewest = true;
+      newestMessage = message;
+    }
+
+    // write the incoming message to DB if incoming message is newest
+    let messageReply: GenericMessageReply;
+    if (incomingMessageIsNewest) {
+      const indexes = ProtocolsConfigureHandler.constructProtocolsConfigureIndexes(protocolsConfigure);
+
+      const messageCid = await Message.getCid(message);
+      await this.messageStore.put(tenant, message, indexes);
+      await this.eventLog.append(tenant, messageCid);
+
+      messageReply = {
+        status: { code: 202, detail: 'Accepted' }
+      };
+    } else {
+      messageReply = {
+        status: { code: 409, detail: 'Conflict' }
+      };
+    }
+
+    // delete all existing records that are smaller
+    const deletedMessageCids: string[] = [];
+    for (const message of existingMessages) {
+      if (await Message.isNewer(newestMessage, message)) {
+        const messageCid = await Message.getCid(message);
+        deletedMessageCids.push(messageCid);
+
+        await this.messageStore.delete(tenant, messageCid);
+      }
+    }
+
+    await this.eventLog.deleteEventsByCid(tenant, deletedMessageCids);
+
+    return messageReply;
+  };
+
+  private static constructProtocolsConfigureIndexes(protocolsConfigure: ProtocolsConfigure): { [key: string]: string | boolean } {
+    // strip out `definition` as it is not indexable
+    const { definition, ...propertiesToIndex } = protocolsConfigure.message.descriptor;
+    const { author } = protocolsConfigure;
+
+    const indexes: { [key: string]: string | boolean } = {
+      ...propertiesToIndex,
+      author    : author!,
+      protocol  : definition.protocol, // retain protocol url from `definition`,
+      published : definition.published
+    };
+
+    return indexes;
+  }
+}

package/src/handlers/protocols-query.ts

@@ -0,0 +1,81 @@
+
+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 { ProtocolsConfigureMessage, ProtocolsQueryMessage, ProtocolsQueryReply } from '../types/protocols-types.js';
+
+import { authenticate } from '../core/auth.js';
+import { DwnErrorCode } from '../core/dwn-error.js';
+import { messageReplyFromError } from '../core/message-reply.js';
+import { ProtocolsQuery } from '../interfaces/protocols-query.js';
+import { removeUndefinedProperties } from '../utils/object.js';
+
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export class ProtocolsQueryHandler implements MethodHandler {
+
+  constructor(private didResolver: DidResolver, private messageStore: MessageStore,private dataStore: DataStore) { }
+
+  public async handle({
+    tenant,
+    message
+  }: { tenant: string, message: ProtocolsQueryMessage}): Promise<ProtocolsQueryReply> {
+
+    let protocolsQuery: ProtocolsQuery;
+    try {
+      protocolsQuery = await ProtocolsQuery.parse(message);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
+    }
+
+    // authentication & authorization
+    try {
+      await authenticate(message.authorization, this.didResolver);
+      await protocolsQuery.authorize(tenant, this.messageStore);
+    } catch (error: any) {
+
+      // return public ProtocolsConfigures if query fails with a certain authentication or authorization code
+      if (error.code === DwnErrorCode.AuthenticateJwsMissing || // unauthenticated
+          error.code === DwnErrorCode.ProtocolsQueryUnauthorized) {
+
+        const entries: ProtocolsConfigureMessage[] = await this.fetchPublishedProtocolsConfigure(tenant, protocolsQuery);
+        return {
+          status: { code: 200, detail: 'OK' },
+          entries
+        };
+      } else {
+        return messageReplyFromError(error, 401);
+      }
+    }
+
+    const query = {
+      ...message.descriptor.filter,
+      interface : DwnInterfaceName.Protocols,
+      method    : DwnMethodName.Configure
+    };
+    removeUndefinedProperties(query);
+
+    const { messages } = await this.messageStore.query(tenant, [ query ]);
+
+    return {
+      status  : { code: 200, detail: 'OK' },
+      entries : messages as ProtocolsConfigureMessage[]
+    };
+  };
+
+  /**
+   * Fetches only published `ProtocolsConfigure`.
+   */
+  private async fetchPublishedProtocolsConfigure(tenant: string, protocolsQuery: ProtocolsQuery): Promise<ProtocolsConfigureMessage[]> {
+    // fetch all published `ProtocolConfigure` matching the query
+    const filter = {
+      ...protocolsQuery.message.descriptor.filter,
+      interface : DwnInterfaceName.Protocols,
+      method    : DwnMethodName.Configure,
+      published : true
+    };
+    const { messages: publishedProtocolsConfigure } = await this.messageStore.query(tenant, [ filter ]);
+    return publishedProtocolsConfigure as ProtocolsConfigureMessage[];
+  }
+}

package/src/handlers/records-delete.ts

@@ -0,0 +1,139 @@
+import type { DataStore } from '../types/data-store.js';
+import type { DidResolver } from '../did/did-resolver.js';
+import type { EventLog } from '../types/event-log.js';
+import type { GenericMessageReply } from '../core/message-reply.js';
+import type { MessageStore } from '../types//message-store.js';
+import type { MethodHandler } from '../types/method-handler.js';
+
+import type { RecordsDeleteMessage, RecordsWriteMessage } from '../types/records-types.js';
+
+import { authenticate } from '../core/auth.js';
+import { Message } from '../core/message.js';
+import { messageReplyFromError } from '../core/message-reply.js';
+import { ProtocolAuthorization } from '../core/protocol-authorization.js';
+import { RecordsDelete } from '../interfaces/records-delete.js';
+import { RecordsWrite } from '../interfaces/records-write.js';
+import { StorageController } from '../store/storage-controller.js';
+import { DwnError, DwnErrorCode } from '../core/dwn-error.js';
+import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
+
+export class RecordsDeleteHandler implements MethodHandler {
+
+  constructor(private didResolver: DidResolver, private messageStore: MessageStore, private dataStore: DataStore, private eventLog: EventLog) { }
+
+  public async handle({
+    tenant,
+    message
+  }: { tenant: string, message: RecordsDeleteMessage}): Promise<GenericMessageReply> {
+
+    let recordsDelete: RecordsDelete;
+    try {
+      recordsDelete = await RecordsDelete.parse(message);
+    } catch (e) {
+      return messageReplyFromError(e, 400);
+    }
+
+    // authentication
+    try {
+      await authenticate(message.authorization, this.didResolver);
+    } catch (e) {
+      return messageReplyFromError(e, 401);
+    }
+
+    // get existing records matching the `recordId`
+    const query = {
+      interface : DwnInterfaceName.Records,
+      recordId  : message.descriptor.recordId
+    };
+    const { messages: existingMessages } = await this.messageStore.query(tenant, [ query ]);
+
+    // find which message is the newest, and if the incoming message is the newest
+    const newestExistingMessage = await Message.getNewestMessage(existingMessages);
+    let incomingMessageIsNewest = false;
+    let newestMessage;
+    // if incoming message is newest
+    if (newestExistingMessage === undefined || await Message.isNewer(message, newestExistingMessage)) {
+      incomingMessageIsNewest = true;
+      newestMessage = message;
+    } else { // existing message is the same age or newer than the incoming message
+      newestMessage = newestExistingMessage;
+    }
+
+    if (!incomingMessageIsNewest) {
+      return {
+        status: { code: 409, detail: 'Conflict' }
+      };
+    }
+
+    // return Not Found if record does not exist or is already deleted
+    if (newestExistingMessage === undefined || newestExistingMessage.descriptor.method === DwnMethodName.Delete) {
+      return {
+        status: { code: 404, detail: 'Not Found' }
+      };
+    }
+
+    // authorization
+    try {
+      await RecordsDeleteHandler.authorizeRecordsDelete(
+        tenant,
+        recordsDelete,
+        await RecordsWrite.parse(newestExistingMessage as RecordsWriteMessage),
+        this.messageStore
+      );
+    } catch (e) {
+      return messageReplyFromError(e, 401);
+    }
+
+    const indexes = await constructIndexes(tenant, recordsDelete);
+    await this.messageStore.put(tenant, message, indexes);
+
+    const messageCid = await Message.getCid(message);
+    await this.eventLog.append(tenant, messageCid);
+
+    // delete all existing messages that are not newest, except for the initial write
+    await StorageController.deleteAllOlderMessagesButKeepInitialWrite(
+      tenant, existingMessages, newestMessage, this.messageStore, this.dataStore, this.eventLog
+    );
+
+    const messageReply = {
+      status: { code: 202, detail: 'Accepted' }
+    };
+    return messageReply;
+  };
+
+  private static async authorizeRecordsDelete(
+    tenant: string, recordsDelete:
+     RecordsDelete, newestRecordsWrite:
+     RecordsWrite, messageStore: MessageStore
+  ): Promise<void> {
+
+    if (recordsDelete.author === tenant) {
+      return;
+    } else if (newestRecordsWrite.message.descriptor.protocol !== undefined) {
+      await ProtocolAuthorization.authorizeDelete(tenant, recordsDelete, newestRecordsWrite, messageStore);
+    } else {
+      throw new DwnError(
+        DwnErrorCode.RecordsDeleteAuthorizationFailed,
+        'RecordsDelete message failed authorization'
+      );
+    }
+  }
+
+}
+
+export async function constructIndexes(tenant: string, recordsDelete: RecordsDelete): Promise<Record<string, string>> {
+  const message = recordsDelete.message;
+  const descriptor = { ...message.descriptor };
+
+  // NOTE: the "trick" not may not be apparent on how a query is able to omit deleted records:
+  // we intentionally not add index for `isLatestBaseState` at all, this means that upon a successful delete,
+  // no messages with the record ID will match any query because queries by design filter by `isLatestBaseState = true`,
+  // `isLatestBaseState` for the initial delete would have been toggled to `false`
+  const indexes: Record<string, any> = {
+    // isLatestBaseState : "true", // intentionally showing that this index is omitted
+    author: recordsDelete.author,
+    ...descriptor
+  };
+
+  return indexes;
+}