feat: refactor account

api/libraries/event-store/aggregates/account.ts

@@ -1,10 +1,10 @@
-import { AggregateRoot, getDate, makeAggregateReducer } from "@valkyr/event-store";
-import { Avatar, Contact, Email, Name, Phone, Strategy } from "relay/schemas";
+import { Strategy } from "@spec/modules/account/strategies.ts";
+import { Avatar, Contact, Email, Name } from "@spec/shared";
+import { AggregateRoot, getDate } from "@valkyr/event-store";
 
-import { db, toAccountDriver } from "~libraries/read-store/mod.ts";
+import { db } from "~libraries/read-store/mod.ts";
 
 import { eventStore } from "../event-store.ts";
-import { AccountCreatedData } from "../events/account.ts";
 import { Auditor } from "../events/auditor.ts";
 import { EventStoreFactory } from "../events/mod.ts";
 import { projector } from "../projector.ts";
@@ -12,69 +12,22 @@ import { projector } from "../projector.ts";
 export class Account extends AggregateRoot<EventStoreFactory> {
   static override readonly name = "account";
 
-  id!: string;
-  organizationId?: string;
-
-  type!: "admin" | "consultant" | "organization";
-
   avatar?: Avatar;
   name?: Name;
   contact: Contact = {
     emails: [],
-    phones: [],
   };
   strategies: Strategy[] = [];
 
   createdAt!: Date;
   updatedAt!: Date;
 
-  // -------------------------------------------------------------------------
-  // Factories
-  // -------------------------------------------------------------------------
-
-  static #reducer = makeAggregateReducer(Account);
-
-  static create(data: AccountCreatedData, meta: Auditor): Account {
-    return new Account().push({
-      type: "account:created",
-      data,
-      meta,
-    });
-  }
-
-  static async getById(stream: string): Promise<Account | undefined> {
-    return this.$store.reduce({ name: "account", stream, reducer: this.#reducer });
-  }
-
-  static async getByEmail(email: string): Promise<Account | undefined> {
-    return this.$store.reduce({ name: "account", relation: Account.emailRelation(email), reducer: this.#reducer });
-  }
-
-  // -------------------------------------------------------------------------
-  // Relations
-  // -------------------------------------------------------------------------
-
-  static emailRelation(email: string): `account:email:${string}` {
-    return `account:email:${email}`;
-  }
-
-  static passwordRelation(alias: string): `account:password:${string}` {
-    return `account:password:${alias}`;
-  }
-
   // -------------------------------------------------------------------------
   // Reducer
   // -------------------------------------------------------------------------
 
   with(event: EventStoreFactory["$events"][number]["$record"]): void {
     switch (event.type) {
-      case "account:created": {
-        this.id = event.stream;
-        this.organizationId = event.data.type === "organization" ? event.data.organizationId : undefined;
-        this.type = event.data.type;
-        this.createdAt = getDate(event.created);
-        break;
-      }
       case "account:avatar:added": {
         this.avatar = { url: event.data };
         this.updatedAt = getDate(event.created);
@@ -90,11 +43,6 @@ export class Account extends AggregateRoot<EventStoreFactory> {
         this.updatedAt = getDate(event.created);
         break;
       }
-      case "account:phone:added": {
-        this.contact.phones.push(event.data);
-        this.updatedAt = getDate(event.created);
-        break;
-      }
       case "strategy:email:added": {
         this.strategies.push({ type: "email", value: event.data });
         this.updatedAt = getDate(event.created);
@@ -139,15 +87,6 @@ export class Account extends AggregateRoot<EventStoreFactory> {
     });
   }
 
-  addPhone(phone: Phone, meta: Auditor): this {
-    return this.push({
-      stream: this.id,
-      type: "account:phone:added",
-      data: phone,
-      meta,
-    });
-  }
-
   addRole(roleId: string, meta: Auditor): this {
     return this.push({
       stream: this.id,
@@ -174,95 +113,40 @@ export class Account extends AggregateRoot<EventStoreFactory> {
       meta,
     });
   }
-
-  // -------------------------------------------------------------------------
-  // Utilities
-  // -------------------------------------------------------------------------
-
-  toSession(): Session {
-    if (this.type === "organization") {
-      if (this.organizationId === undefined) {
-        throw new Error("Account .toSession failed, no organization id present");
-      }
-      return {
-        type: this.type,
-        accountId: this.id,
-        organizationId: this.organizationId,
-      };
-    }
-    return {
-      type: this.type,
-      accountId: this.id,
-    };
-  }
 }
 
-/*
- |--------------------------------------------------------------------------------
- | Types
- |--------------------------------------------------------------------------------
- */
-
-type Session =
-  | {
-      type: "organization";
-      accountId: string;
-      organizationId: string;
-    }
-  | {
-      type: "admin" | "consultant";
-      accountId: string;
-    };
-
 /*
  |--------------------------------------------------------------------------------
  | Projectors
  |--------------------------------------------------------------------------------
  */
 
-projector.on("account:created", async ({ stream, data }) => {
-  const schema: any = {
-    id: stream,
-    type: data.type,
-    contact: {
-      emails: [],
-      phones: [],
-    },
-    strategies: [],
-    roles: [],
-  };
-  if (data.type === "organization") {
-    schema.organizationId = data.organizationId;
-  }
-  await db.collection("accounts").insertOne(toAccountDriver(schema));
-});
-
 projector.on("account:avatar:added", async ({ stream: id, data: url }) => {
-  await db.collection("accounts").updateOne({ id }, { $set: { avatar: { url } } });
+  await db.collection("accounts").updateOne({ id }, { $set: { avatar: { url } } }, { upsert: true });
 });
 
 projector.on("account:name:added", async ({ stream: id, data: name }) => {
-  await db.collection("accounts").updateOne({ id }, { $set: { name } });
+  await db.collection("accounts").updateOne({ id }, { $set: { name } }, { upsert: true });
 });
 
 projector.on("account:email:added", async ({ stream: id, data: email }) => {
-  await db.collection("accounts").updateOne({ id }, { $push: { "contact.emails": email } });
-});
-
-projector.on("account:phone:added", async ({ stream: id, data: phone }) => {
-  await db.collection("accounts").updateOne({ id }, { $push: { "contact.phones": phone } });
+  await db.collection("accounts").updateOne({ id }, { $push: { "contact.emails": email } }, { upsert: true });
 });
 
 projector.on("account:role:added", async ({ stream: id, data: roleId }) => {
-  await db.collection("accounts").updateOne({ id }, { $push: { roles: roleId } });
+  await db.collection("accounts").updateOne({ id }, { $push: { roles: roleId } }, { upsert: true });
 });
 
 projector.on("strategy:email:added", async ({ stream: id, data: email }) => {
-  await eventStore.relations.insert(Account.emailRelation(email), id);
-  await db.collection("accounts").updateOne({ id }, { $push: { strategies: { type: "email", value: email } } });
+  await eventStore.relations.insert(`account:email:${email}`, id);
+  await db
+    .collection("accounts")
+    .updateOne({ id }, { $push: { strategies: { type: "email", value: email } } }, { upsert: true });
 });
 
 projector.on("strategy:password:added", async ({ stream: id, data: strategy }) => {
-  await eventStore.relations.insert(Account.passwordRelation(strategy.alias), id);
-  await db.collection("accounts").updateOne({ id }, { $push: { strategies: { type: "password", ...strategy } } });
+  await eventStore.relations.insert(`account:alias:${strategy.alias}`, id);
+  await db
+    .collection("accounts")
+    .updateOne({ id }, { $push: { strategies: { type: "password", ...strategy } } }, { upsert: true });
 });