@powerhousedao/renown-package 0.0.0 → 0.0.2

package/dist/subgraphs/renown-credential/index.d.ts

@@ -0,0 +1,10 @@
+import { Subgraph } from "@powerhousedao/reactor-api";
+import type { DocumentNode } from "graphql";
+export declare class RenownCredentialSubgraph extends Subgraph {
+    name: string;
+    typeDefs: DocumentNode;
+    resolvers: Record<string, unknown>;
+    additionalContextFields: {};
+    onSetup(): Promise<void>;
+    onDisconnect(): Promise<void>;
+}

package/dist/subgraphs/renown-credential/index.js

@@ -0,0 +1,11 @@
+import { Subgraph } from "@powerhousedao/reactor-api";
+import { schema } from "./schema.js";
+import { getResolvers } from "./resolvers.js";
+export class RenownCredentialSubgraph extends Subgraph {
+    name = "renown-credential";
+    typeDefs = schema;
+    resolvers = getResolvers(this);
+    additionalContextFields = {};
+    async onSetup() { }
+    async onDisconnect() { }
+}

package/dist/subgraphs/renown-credential/resolvers.d.ts

@@ -0,0 +1,2 @@
+import { type Subgraph } from "@powerhousedao/reactor-api";
+export declare const getResolvers: (subgraph: Subgraph) => Record<string, unknown>;

package/dist/subgraphs/renown-credential/resolvers.js

@@ -0,0 +1,96 @@
+import { addFile } from "document-drive";
+import { actions, } from "../../document-models/renown-credential/index.js";
+import { setName } from "document-model";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    return {
+        Query: {
+            RenownCredential: async () => {
+                return {
+                    getDocument: async (args) => {
+                        const { docId, driveId } = args;
+                        if (!docId) {
+                            throw new Error("Document id is required");
+                        }
+                        if (driveId) {
+                            const docIds = await reactor.getDocuments(driveId);
+                            if (!docIds.includes(docId)) {
+                                throw new Error(`Document with id ${docId} is not part of ${driveId}`);
+                            }
+                        }
+                        const doc = await reactor.getDocument(docId);
+                        return {
+                            driveId: driveId,
+                            ...doc,
+                            ...doc.header,
+                            created: doc.header.createdAtUtcIso,
+                            lastModified: doc.header.lastModifiedAtUtcIso,
+                            state: doc.state.global,
+                            stateJSON: doc.state.global,
+                            revision: doc.header?.revision?.global ?? 0,
+                        };
+                    },
+                    getDocuments: async (args) => {
+                        const { driveId } = args;
+                        const docsIds = await reactor.getDocuments(driveId);
+                        const docs = await Promise.all(docsIds.map(async (docId) => {
+                            const doc = await reactor.getDocument(docId);
+                            return {
+                                driveId: driveId,
+                                ...doc,
+                                ...doc.header,
+                                created: doc.header.createdAtUtcIso,
+                                lastModified: doc.header.lastModifiedAtUtcIso,
+                                state: doc.state.global,
+                                stateJSON: doc.state.global,
+                                revision: doc.header?.revision?.global ?? 0,
+                            };
+                        }));
+                        return docs.filter((doc) => doc.header.documentType === "renown/credential");
+                    },
+                };
+            },
+        },
+        Mutation: {
+            RenownCredential_createDocument: async (_, args) => {
+                const { driveId, name } = args;
+                const document = await reactor.addDocument("renown/credential");
+                if (driveId) {
+                    await reactor.addAction(driveId, addFile({
+                        name,
+                        id: document.header.id,
+                        documentType: "renown/credential",
+                    }));
+                }
+                if (name) {
+                    await reactor.addAction(document.header.id, setName(name));
+                }
+                return document.header.id;
+            },
+            RenownCredential_init: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.init(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to init");
+                }
+                return true;
+            },
+            RenownCredential_revoke: async (_, args) => {
+                const { docId, input } = args;
+                const doc = await reactor.getDocument(docId);
+                if (!doc) {
+                    throw new Error("Document not found");
+                }
+                const result = await reactor.addAction(docId, actions.revoke(input));
+                if (result.status !== "SUCCESS") {
+                    throw new Error(result.error?.message ?? "Failed to revoke");
+                }
+                return true;
+            },
+        },
+    };
+};

package/dist/subgraphs/renown-credential/schema.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentNode } from "graphql";
+export declare const schema: DocumentNode;

package/dist/subgraphs/renown-credential/schema.js

@@ -0,0 +1,60 @@
+import { gql } from "graphql-tag";
+export const schema = gql `
+  """
+  Subgraph definition for RenownCredential (renown/credential)
+  """
+  type RenownCredentialState {
+    "Add your global state fields here"
+    jwt: String
+    revoked: Boolean
+    issuer: String
+    subject: String
+    audience: String
+    payload: String
+  }
+
+  """
+  Queries: RenownCredential
+  """
+  type RenownCredentialQueries {
+    getDocument(docId: PHID!, driveId: PHID): RenownCredential
+    getDocuments(driveId: String!): [RenownCredential!]
+  }
+
+  type Query {
+    RenownCredential: RenownCredentialQueries
+  }
+
+  """
+  Mutations: RenownCredential
+  """
+  type Mutation {
+    RenownCredential_createDocument(name: String!, driveId: String): String
+
+    RenownCredential_init(
+      driveId: String
+      docId: PHID
+      input: RenownCredential_InitInput
+    ): Int
+    RenownCredential_revoke(
+      driveId: String
+      docId: PHID
+      input: RenownCredential_RevokeInput
+    ): Int
+  }
+
+  """
+  Module: Manager
+  """
+  input RenownCredential_InitInput {
+    "Add your inputs here"
+    jwt: String!
+    issuer: String
+    subject: String
+    audience: String
+    payload: String
+  }
+  input RenownCredential_RevokeInput {
+    jwt: String
+  }
+`;

package/dist/subgraphs/renown-read-model/resolvers.js

@@ -1,105 +1,9 @@
-import { RenownUserProcessor } from "../../processors/renown-user/index.js";
-const mapToProfile = (user) => ({
-    documentId: user.document_id,
-    username: user.username,
-    ethAddress: user.eth_address,
-    userImage: user.user_image,
-    createdAt: user.created_at,
-    updatedAt: user.updated_at,
-});
 export const getResolvers = (subgraph) => {
-    const db = subgraph.relationalDb;
+    const reactor = subgraph.reactor;
     return {
         Query: {
-            getProfile: async (parent, args) => {
-                const { driveId, id, username, ethAddress, searchInput } = args.input;
-                let query = RenownUserProcessor.query(driveId, db).selectFrom("renown_user");
-                // Priority: id > username > ethAddress > searchInput
-                if (id) {
-                    query = query.where("renown_user.document_id", "=", id);
-                }
-                else if (username) {
-                    query = query.where("renown_user.username", "=", username);
-                }
-                else if (ethAddress) {
-                    query = query.where("renown_user.eth_address", "=", ethAddress);
-                }
-                else if (searchInput) {
-                    // Search across username and eth_address
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.username", "like", `%${searchInput}%`),
-                        eb("renown_user.eth_address", "like", `%${searchInput}%`),
-                    ]));
-                }
-                else {
-                    throw new Error("At least one of id, username, ethAddress, or searchInput must be provided");
-                }
-                const result = await query.selectAll().executeTakeFirst();
-                return result ? mapToProfile(result) : null;
-            },
-            getProfiles: async (parent, args) => {
-                const { driveId, ids, usernames, ethAddresses, searchString } = args.input;
-                let query = RenownUserProcessor.query(driveId, db).selectFrom("renown_user");
-                // Build OR conditions based on provided inputs
-                if (ids && ids.length > 0) {
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.document_id", "in", ids),
-                        ...(usernames && usernames.length > 0
-                            ? [eb("renown_user.username", "in", usernames)]
-                            : []),
-                        ...(ethAddresses && ethAddresses.length > 0
-                            ? [eb("renown_user.eth_address", "in", ethAddresses)]
-                            : []),
-                        ...(searchString
-                            ? [
-                                eb.or([
-                                    eb("renown_user.username", "like", `%${searchString}%`),
-                                    eb("renown_user.eth_address", "like", `%${searchString}%`),
-                                ]),
-                            ]
-                            : []),
-                    ]));
-                }
-                else if (usernames && usernames.length > 0) {
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.username", "in", usernames),
-                        ...(ethAddresses && ethAddresses.length > 0
-                            ? [eb("renown_user.eth_address", "in", ethAddresses)]
-                            : []),
-                        ...(searchString
-                            ? [
-                                eb.or([
-                                    eb("renown_user.username", "like", `%${searchString}%`),
-                                    eb("renown_user.eth_address", "like", `%${searchString}%`),
-                                ]),
-                            ]
-                            : []),
-                    ]));
-                }
-                else if (ethAddresses && ethAddresses.length > 0) {
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.eth_address", "in", ethAddresses),
-                        ...(searchString
-                            ? [
-                                eb.or([
-                                    eb("renown_user.username", "like", `%${searchString}%`),
-                                    eb("renown_user.eth_address", "like", `%${searchString}%`),
-                                ]),
-                            ]
-                            : []),
-                    ]));
-                }
-                else if (searchString) {
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.username", "like", `%${searchString}%`),
-                        eb("renown_user.eth_address", "like", `%${searchString}%`),
-                    ]));
-                }
-                else {
-                    throw new Error("At least one of ids, usernames, ethAddresses, or searchString must be provided");
-                }
-                const results = await query.selectAll().execute();
-                return results.map(mapToProfile);
+            example: async (parent, args) => {
+                return "example";
             },
         },
     };

package/dist/subgraphs/renown-read-model/schema.js

@@ -1,35 +1,9 @@
 import { gql } from "graphql-tag";
 export const schema = gql `
   """
-  Subgraph definition for Renown Read Model
+  Subgraph definition
   """
-  type RenownProfile {
-    documentId: String!
-    username: String
-    ethAddress: String
-    userImage: String
-    createdAt: String
-    updatedAt: String
-  }
-
-  input GetProfileInput {
-    driveId: String!
-    id: String
-    username: String
-    ethAddress: String
-    searchInput: String
-  }
-
-  input GetProfilesInput {
-    driveId: String!
-    ids: [String!]
-    usernames: [String!]
-    ethAddresses: [String!]
-    searchString: String
-  }
-
   type Query {
-    getProfile(input: GetProfileInput!): RenownProfile
-    getProfiles(input: GetProfilesInput!): [RenownProfile!]!
+    example(driveId: String!): String
   }
 `;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/renown-package",
   "description": "",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "license": "AGPL-3.0-only",
   "type": "module",
   "files": [