@powerhousedao/reactor-api 1.21.2 → 1.22.0

package/src/subgraphs/drive/index.ts

@@ -1,434 +0,0 @@
-import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
-import { pascalCase } from "change-case";
-import {
-  generateUUID,
-  ListenerRevision,
-  StrandUpdateGraphQL,
-} from "document-drive";
-import {
-  actions,
-  FileNode,
-  Listener,
-  ListenerFilter,
-  TransmitterType,
-} from "document-model-libs/document-drive";
-import { Document, Operation } from "document-model/document";
-import {
-  DocumentModelInput,
-  DocumentModelState,
-} from "document-model/document-model";
-import { gql } from "graphql-tag";
-import {
-  InternalStrandUpdate,
-  processAcknowledge,
-  processGetStrands,
-  processPushUpdate,
-} from "src/sync/utils";
-import { Subgraph } from "../base";
-import { Context, SubgraphArgs } from "../types";
-import { Asset } from "./temp-hack-rwa-type-defs";
-
-const ENABLE_SYNC_DEBUG = false;
-
-const driveKindTypeNames: Record<string, string> = {
-  file: "DocumentDrive_FileNode",
-  folder: "DocumentDrive_FolderNode",
-};
-
-export class DriveSubgraph extends Subgraph {
-  private debugID = `[DSG #${Math.floor(Math.random() * 999)}]`;
-
-  constructor(args: SubgraphArgs) {
-    super(args);
-    this.debugLog(`constructor()`);
-  }
-
-  private debugLog(...data: any[]) {
-    if (!ENABLE_SYNC_DEBUG) {
-      return;
-    }
-
-    if (data.length > 0 && typeof data[0] === "string") {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      console.log(`${this.debugID} ${data[0]}`, ...data.slice(1));
-    } else {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      console.log(this.debugID, ...data);
-    }
-  }
-
-  name = "d/:drive";
-  typeDefs = gql`
-    type Query {
-      system: System
-      drive: DocumentDrive_DocumentDriveState
-      document(id: String!): IDocument
-      documents: [String!]!
-    }
-
-    type Mutation {
-      registerPullResponderListener(
-        filter: InputListenerFilter!
-      ): DocumentDrive_Listener
-      pushUpdates(strands: [InputStrandUpdate!]): [ListenerRevision!]!
-      acknowledge(
-        listenerId: String!
-        revisions: [ListenerRevisionInput]
-      ): Boolean
-    }
-
-    input InputOperationSignerUser {
-      address: String!
-      networkId: String!
-      chainId: Int!
-    }
-
-    type OperationSignerUser {
-      address: String!
-      networkId: String!
-      chainId: Int!
-    }
-
-    input InputOperationSignerApp {
-      name: String!
-      key: String!
-    }
-
-    type OperationSignerApp {
-      name: String!
-      key: String!
-    }
-
-    type OperationSigner {
-      app: OperationSignerApp
-      user: OperationSignerUser
-      signatures: [[String!]]!
-    }
-
-    input InputOperationSigner {
-      app: InputOperationSignerApp
-      user: InputOperationSignerUser
-      signatures: [[String!]]!
-    }
-
-    type OperationContext {
-      signer: OperationSigner
-    }
-
-    input InputOperationContext {
-      signer: InputOperationSigner
-    }
-
-    input InputOperationUpdate {
-      index: Int!
-      skip: Int
-      type: String!
-      id: String!
-      input: String!
-      hash: String!
-      timestamp: String!
-      error: String
-      context: InputOperationContext
-    }
-
-    type OperationUpdate {
-      index: Int!
-      skip: Int
-      type: String!
-      id: String!
-      input: String!
-      hash: String!
-      timestamp: String!
-      error: String
-      context: OperationContext
-    }
-
-    type StrandUpdate {
-      driveId: String!
-      documentId: String!
-      scope: String!
-      branch: String!
-      operations: [OperationUpdate!]!
-    }
-
-    input InputStrandUpdate {
-      driveId: String!
-      documentId: String!
-      scope: String!
-      branch: String!
-      operations: [InputOperationUpdate!]!
-    }
-
-    input InputListenerFilter {
-      documentType: [String!]
-      documentId: [String!]
-      scope: [String!]
-      branch: [String!]
-    }
-
-    enum UpdateStatus {
-      SUCCESS
-      MISSING
-      CONFLICT
-      ERROR
-    }
-
-    input ListenerRevisionInput {
-      driveId: String!
-      documentId: String!
-      scope: String!
-      branch: String!
-      status: UpdateStatus!
-      revision: Int!
-    }
-
-    type ListenerRevision {
-      driveId: String!
-      documentId: String!
-      scope: String!
-      branch: String!
-      status: UpdateStatus!
-      revision: Int!
-      error: String
-    }
-
-    type System {
-      sync: Sync
-    }
-
-    type Sync {
-      strands(listenerId: ID!, since: String): [StrandUpdate!]!
-    }
-  `;
-
-  resolvers: GraphQLResolverMap<Context> = {
-    Asset: {
-      __resolveType: (obj: Asset) => {
-        return obj.type;
-      },
-    },
-    Node: {
-      __resolveType: (obj: FileNode) => {
-        return obj.documentType ? "FileNode" : "FolderNode";
-      },
-    },
-    Document: {
-      operations: async (
-        obj: Document,
-        { first, skip }: { first: number; skip: number },
-        ctx: Context,
-      ) => {
-        const limit = first ?? 0;
-        const start = skip ?? 0;
-        return obj.operations.global.slice(start, start + limit);
-      },
-    },
-    Query: {
-      drive: async (_: unknown, args: unknown, ctx: Context) => {
-        this.debugLog(`drive()`, args);
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-        const drive = await this.reactor.getDrive(ctx.driveId);
-        return {
-          ...drive.state.global,
-          nodes: drive.state.global.nodes.map((n) => ({
-            ...n,
-            __typename: driveKindTypeNames[n.kind] || "UnkownDriveNode",
-          })),
-        };
-      },
-      documents: async (_: unknown, args: unknown, ctx: Context) => {
-        this.debugLog(`documents(drive: ${ctx.driveId})`, args);
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-        const documents = await this.reactor.getDocuments(ctx.driveId);
-        return documents;
-      },
-      document: async (_: unknown, { id }: { id: string }, ctx: Context) => {
-        this.debugLog(`document(drive: ${ctx.driveId}, id: ${id})`);
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-        const document = await this.reactor.getDocument(ctx.driveId, id);
-
-        const dms = this.reactor.getDocumentModels();
-        const dm = dms.find(
-          ({ documentModel }: { documentModel: DocumentModelState }) =>
-            documentModel.id === document.documentType,
-        );
-        const globalState = document.state.global;
-        if (!globalState) throw new Error("Document not found");
-        const typeName = pascalCase(
-          (dm?.documentModel.name || "").replaceAll("/", " "),
-        );
-        const response = {
-          ...document,
-          id,
-          revision: document.revision.global,
-          state: document.state.global,
-          operations: document.operations.global.map((op: Operation) => ({
-            ...op,
-            inputText:
-              typeof op.input === "string"
-                ? op.input
-                : JSON.stringify(op.input),
-          })),
-          initialState: document.initialState.state.global,
-          __typename: typeName,
-        };
-        return response;
-      },
-      system: () => ({ sync: {} }),
-    },
-    Mutation: {
-      registerPullResponderListener: async (
-        _: unknown,
-        { filter }: { filter: ListenerFilter },
-        ctx: Context,
-      ) => {
-        this.debugLog(
-          `registerPullResponderListener(drive: ${ctx.driveId})`,
-          filter,
-        );
-
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-        const uuid = generateUUID();
-        const listener: Listener = {
-          block: false,
-          callInfo: {
-            data: "",
-            name: "PullResponder",
-            transmitterType: "PullResponder" as TransmitterType,
-          },
-          filter: {
-            branch: filter.branch ?? [],
-            documentId: filter.documentId ?? [],
-            documentType: filter.documentType ?? [],
-            scope: filter.scope ?? [],
-          },
-          label: `Pullresponder #${uuid}`,
-          listenerId: uuid,
-          system: false,
-        };
-
-        const result = await this.reactor.queueDriveAction(
-          ctx.driveId,
-          actions.addListener({ listener }),
-        );
-
-        if (result.status !== "SUCCESS" && result.error) {
-          throw new Error(
-            `Listener couldn't be registered: ${result.error.message}`,
-          );
-        }
-
-        return listener;
-      },
-      pushUpdates: async (
-        _: unknown,
-        { strands: strandsGql }: { strands: StrandUpdateGraphQL[] },
-        ctx: Context,
-      ) => {
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-        this.debugLog(`pushUpdates(drive: ${ctx.driveId})`, strandsGql);
-
-        // translate data types
-        const strands: InternalStrandUpdate[] = strandsGql.map((strandGql) => {
-          return {
-            operations: strandGql.operations.map((op) => ({
-              ...op,
-              input: JSON.parse(op.input) as DocumentModelInput,
-              skip: op.skip ?? 0,
-              scope: strandGql.scope,
-              branch: "main",
-            })) as Operation[],
-            documentId: strandGql.documentId,
-            driveId: strandGql.driveId,
-            scope: strandGql.scope,
-            branch: strandGql.branch,
-          };
-        });
-
-        // return a list of listener revisions
-        return await Promise.all(
-          strands.map((strand) => processPushUpdate(this.reactor, strand)),
-        );
-      },
-      acknowledge: async (
-        _: unknown,
-        {
-          listenerId,
-          revisions,
-        }: { listenerId: string; revisions: ListenerRevision[] },
-        ctx: Context,
-      ) => {
-        this.debugLog(
-          `acknowledge(drive: ${ctx.driveId}, listenerId: ${listenerId})`,
-          revisions,
-        );
-
-        if (!listenerId || !revisions) return false;
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-
-        // translate data types
-        const validEntries = revisions
-          .filter((r) => r !== null)
-          .map((e) => ({
-            driveId: e.driveId,
-            documentId: e.documentId,
-            scope: e.scope,
-            branch: e.branch,
-            revision: e.revision,
-            status: e.status,
-          }));
-
-        // return a boolean indicating if the acknowledge was successful
-        return await processAcknowledge(
-          this.reactor,
-          ctx.driveId,
-          listenerId,
-          validEntries,
-        );
-      },
-    },
-    System: {},
-    Sync: {
-      strands: async (
-        _: unknown,
-        {
-          listenerId,
-          since,
-        }: { listenerId: string; since: string | undefined },
-        ctx: Context,
-      ) => {
-        this.debugLog(
-          `strands(drive: ${ctx.driveId}, listenerId: ${listenerId}, since:${since})`,
-        );
-        if (!ctx.driveId) throw new Error("Drive ID is required");
-
-        // get the requested strand updates
-        const strands = await processGetStrands(
-          this.reactor,
-          ctx.driveId,
-          listenerId,
-          since,
-        );
-
-        // translate data types
-        return strands.map((update) => ({
-          driveId: update.driveId,
-          documentId: update.documentId,
-          scope: update.scope,
-          branch: update.branch,
-          operations: update.operations.map((op) => ({
-            index: op.index,
-            skip: op.skip,
-            name: op.type,
-            input: JSON.stringify(op.input),
-            hash: op.hash,
-            timestamp: op.timestamp,
-            type: op.type,
-            context: op.context,
-            id: op.id,
-          })),
-        }));
-      },
-    },
-  };
-}

package/src/subgraphs/drive/temp-hack-rwa-type-defs.ts

@@ -1,39 +0,0 @@
-import { Maybe } from "document-model/document-model";
-
-export type Scalars = {
-  ID: { input: string; output: string };
-  String: { input: string; output: string };
-  Boolean: { input: boolean; output: boolean };
-  Int: { input: number; output: number };
-  Float: { input: number; output: number };
-  DateTime: { input: string; output: string };
-};
-export type Asset = Cash | FixedIncome;
-
-export type AssetType = "Cash" | "FixedIncome";
-export type Cash = {
-  balance: Scalars["Float"]["output"];
-  currency: Scalars["String"]["output"];
-  id: Scalars["ID"]["output"];
-  spvId: Scalars["ID"]["output"];
-  type: AssetType | `${AssetType}`;
-};
-export type FixedIncome = {
-  CUSIP: Maybe<Scalars["String"]["output"]>;
-  ISIN: Maybe<Scalars["String"]["output"]>;
-  assetProceeds: Scalars["Float"]["output"];
-  coupon: Maybe<Scalars["Float"]["output"]>;
-  fixedIncomeTypeId: Scalars["ID"]["output"];
-  id: Scalars["ID"]["output"];
-  maturity: Maybe<Scalars["DateTime"]["output"]>;
-  name: Scalars["String"]["output"];
-  notional: Scalars["Float"]["output"];
-  purchaseDate: Scalars["DateTime"]["output"];
-  purchasePrice: Scalars["Float"]["output"];
-  purchaseProceeds: Scalars["Float"]["output"];
-  realizedSurplus: Scalars["Float"]["output"];
-  salesProceeds: Scalars["Float"]["output"];
-  spvId: Scalars["ID"]["output"];
-  totalDiscount: Scalars["Float"]["output"];
-  type: AssetType | `${AssetType}`;
-};

package/src/subgraphs/index.ts

@@ -1,24 +0,0 @@
-import { Subgraph } from "./base";
-
-export * as analyticsSubgraph from "./analytics";
-export * as driveSubgraph from "./drive";
-export * as systemSubgraph from "./system";
-export * as authSubgraph from "./auth";
-export * from "./types";
-export { Subgraph } from "./base";
-
-export type SubgraphClass = typeof Subgraph;
-export function isSubgraphClass(
-  candidate: unknown,
-): candidate is SubgraphClass {
-  if (typeof candidate !== "function") return false;
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  let proto = Object.getPrototypeOf(candidate);
-  while (proto) {
-    if (Object.prototype.isPrototypeOf.call(proto, Subgraph)) return true;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    proto = Object.getPrototypeOf(proto);
-  }
-
-  return false;
-}

package/src/subgraphs/manager.ts

@@ -1,128 +0,0 @@
-import { ApolloServer } from "@apollo/server";
-import { expressMiddleware } from "@apollo/server/express4";
-import { ApolloServerPluginInlineTraceDisabled } from "@apollo/server/plugin/disabled";
-import { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
-import bodyParser from "body-parser";
-import cors from "cors";
-import { IDocumentDriveServer } from "document-drive";
-import express, { IRouter, Router } from "express";
-import { Db } from "src/types";
-import { authSubgraph, Context, SubgraphArgs, SubgraphClass } from ".";
-import { createSchema } from "../utils/create-schema";
-import { AnalyticsSubgraph } from "./analytics";
-import { Subgraph } from "./base";
-import { DriveSubgraph } from "./drive";
-import { SystemSubgraph } from "./system";
-import { AuthSubgraph } from "./auth";
-
-export class SubgraphManager {
-  private reactorRouter: IRouter = Router();
-  private contextFields: Record<string, any> = {};
-  private subgraphs: Subgraph[] = [];
-
-  constructor(
-    private readonly path: string,
-    private readonly app: express.Express,
-    private readonly reactor: IDocumentDriveServer,
-    private readonly operationalStore: Db,
-    private readonly analyticsStore: IAnalyticsStore,
-  ) {
-    // Setup Default subgraphs
-    this.registerSubgraph(AuthSubgraph);
-    this.registerSubgraph(SystemSubgraph);
-    this.registerSubgraph(DriveSubgraph);
-    this.registerSubgraph(AnalyticsSubgraph);
-  }
-
-  async init() {
-    console.log(`Initializing Subgraph Manager...`);
-    const models = this.reactor.getDocumentModels();
-    const driveModel = models.find(
-      (it) => it.documentModel.name === "DocumentDrive",
-    );
-    if (!driveModel) {
-      throw new Error("DocumentDrive model required");
-    }
-
-    this.reactor.on("documentModels", () => {
-      this.updateRouter().catch((error: unknown) => console.error(error));
-    });
-
-    this.app.use(this.path, (req, res, next) =>
-      this.reactorRouter(req, res, next),
-    );
-
-    await this.updateRouter();
-  }
-
-  async updateRouter() {
-    const newRouter = Router();
-    newRouter.use(cors());
-    newRouter.use(bodyParser.json());
-    // Run each subgraph on the same http server, but at different paths
-    for (const subgraph of this.subgraphs) {
-      const subgraphConfig = this.#getLocalSubgraphConfig(subgraph.name);
-      if (!subgraphConfig) continue;
-      // get schema
-      const schema = createSchema(
-        this.reactor,
-        subgraphConfig.resolvers,
-        subgraphConfig.typeDefs,
-      );
-      // create apollo server
-      const server = new ApolloServer({
-        schema,
-        introspection: true,
-        plugins: [ApolloServerPluginInlineTraceDisabled()],
-      });
-
-      // start apollo server
-      await server.start();
-
-      // setup path
-      const path = `/${subgraphConfig.name}`;
-      newRouter.use(
-        path,
-        // @ts-ignore
-        expressMiddleware(server, {
-          context: ({ req }): Context => ({
-            headers: req.headers,
-            driveId: req.params.drive ?? undefined,
-            driveServer: this.reactor,
-            db: this.operationalStore,
-            ...this.getAdditionalContextFields(),
-          }),
-        }),
-      );
-    }
-
-    this.reactorRouter = newRouter;
-  }
-
-  async registerSubgraph(subgraph: SubgraphClass) {
-    const subgraphInstance = new subgraph({
-      operationalStore: this.operationalStore,
-      analyticsStore: this.analyticsStore,
-      reactor: this.reactor,
-      subgraphManager: this,
-    });
-    await subgraphInstance.onSetup();
-    this.subgraphs.unshift(subgraphInstance);
-    console.log(
-      `> Registered ${this.path.endsWith("/") ? this.path : this.path + "/"}${subgraphInstance.name} subgraph.`,
-    );
-    await this.updateRouter();
-  }
-
-  #getLocalSubgraphConfig(subgraphName: string) {
-    return this.subgraphs.find((it) => it.name === subgraphName);
-  }
-
-  getAdditionalContextFields = () => {
-    return this.contextFields;
-  };
-
-  setAdditionalContextFields(fields: Record<string, any>) {
-    this.contextFields = { ...this.contextFields, ...fields };
-  }
-}

package/src/subgraphs/system/env/getters.ts

@@ -1,7 +0,0 @@
-export const getAdminUsers = (): string[] => {
-  return (
-    process.env.ADMIN_USERS?.split(",").map((user) =>
-      user.trim().toLocaleLowerCase(),
-    ) || []
-  );
-};

package/src/subgraphs/system/index.ts

@@ -1,73 +0,0 @@
-import { DriveInput } from "document-drive";
-import { GraphQLError } from "graphql";
-import { gql } from "graphql-tag";
-import { Subgraph } from "../base";
-import { ADMIN_USERS } from "./env";
-import { SystemContext } from "./types";
-
-export class SystemSubgraph extends Subgraph {
-  name = "system";
-
-  typeDefs = gql`
-    type Query {
-      drives: [String!]!
-      driveIdBySlug(slug: String!): String
-    }
-
-    type Mutation {
-      addDrive(
-        global: DocumentDriveStateInput!
-      ): DocumentDrive_DocumentDriveState
-      deleteDrive(id: ID!): Boolean
-      setDriveIcon(id: String!, icon: String!): Boolean
-      setDriveName(id: String!, name: String!): Boolean
-    }
-
-    input DocumentDriveStateInput {
-      name: String
-      id: String
-      slug: String
-      icon: String
-    }
-  `;
-
-  resolvers = {
-    Query: {
-      drives: async () => {
-        return await this.reactor.getDrives();
-      },
-    },
-    Mutation: {
-      addDrive: async (
-        parent: unknown,
-        args: DriveInput,
-        ctx: SystemContext,
-      ) => {
-        try {
-          const isAdmin = ctx.isAdmin(ctx);
-          if (!isAdmin) {
-            throw new GraphQLError("Unauthorized");
-          }
-          const drive = await this.reactor.addDrive(args);
-          return drive.state.global;
-        } catch (e) {
-          console.error(e);
-          throw new Error(e as string);
-        }
-      },
-    },
-  };
-
-  async onSetup() {
-    await super.onSetup();
-    this.subgraphManager.setAdditionalContextFields({
-      isAdmin: (ctx: SystemContext) => {
-        return (
-          ADMIN_USERS.length === 0 ||
-          (ctx.session.address &&
-            ADMIN_USERS.includes(ctx.session.address.toLocaleLowerCase()))
-        );
-      },
-    });
-  }
-}

package/src/subgraphs/system/types.ts

@@ -1,5 +0,0 @@
-import { AuthContext } from "../auth/types";
-
-export type SystemContext = AuthContext & {
-  isAdmin: (ctx: AuthContext) => boolean;
-};