@powerhousedao/renown-package 0.0.3 → 0.0.4

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

@@ -1,5 +1,6 @@
 import { RenownUserProcessor } from "../../processors/renown-user/index.js";
-const mapToProfile = (user) => ({
+import { RenownCredentialProcessor } from "../../processors/renown-credential/index.js";
+const mapToUser = (user) => ({
     documentId: user.document_id,
     username: user.username,
     ethAddress: user.eth_address,
@@ -7,99 +8,121 @@ const mapToProfile = (user) => ({
     createdAt: user.created_at,
     updatedAt: user.updated_at,
 });
+const mapToCredential = (credential) => ({
+    documentId: credential.document_id,
+    credentialId: credential.credential_id,
+    context: JSON.parse(credential.context),
+    type: JSON.parse(credential.type),
+    issuer: credential.issuer,
+    issuanceDate: credential.issuance_date,
+    credentialSubject: credential.credential_subject,
+    expirationDate: credential.expiration_date,
+    credentialStatus: credential.credential_status_id &&
+        credential.credential_status_type &&
+        credential.credential_status_purpose &&
+        credential.credential_status_list_index &&
+        credential.credential_status_list_credential
+        ? {
+            id: credential.credential_status_id,
+            type: credential.credential_status_type,
+            statusPurpose: credential.credential_status_purpose,
+            statusListIndex: credential.credential_status_list_index,
+            statusListCredential: credential.credential_status_list_credential,
+        }
+        : null,
+    jwt: credential.jwt,
+    revoked: credential.revoked,
+    revokedAt: credential.revoked_at,
+    revocationReason: credential.revocation_reason,
+    createdAt: credential.created_at,
+    updatedAt: credential.updated_at,
+});
+const getDriveId = (driveId) => {
+    const resolvedDriveId = driveId || process.env.RENOWN_PROFILES_DRIVE_ID;
+    if (!resolvedDriveId) {
+        throw new Error("Drive ID is required. Provide it in the input or set RENOWN_PROFILES_DRIVE_ID environment variable.");
+    }
+    return resolvedDriveId;
+};
 export const getResolvers = (subgraph) => {
     const db = subgraph.relationalDb;
     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);
+            renownUser: async (parent, args) => {
+                const { driveId, phid, ethAddress, username } = args.input;
+                const resolvedDriveId = getDriveId(driveId);
+                let query = RenownUserProcessor.query(resolvedDriveId, db).selectFrom("renown_user");
+                // Priority: phid > ethAddress > username
+                if (phid) {
+                    query = query.where("renown_user.document_id", "=", phid);
                 }
                 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 if (username) {
+                    query = query.where("renown_user.username", "=", username);
                 }
                 else {
-                    throw new Error("At least one of id, username, ethAddress, or searchInput must be provided");
+                    throw new Error("At least one of phid, ethAddress, or username must be provided");
                 }
                 const result = await query.selectAll().executeTakeFirst();
-                return result ? mapToProfile(result) : null;
+                return result ? mapToUser(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}%`),
-                                ]),
-                            ]
-                            : []),
-                    ]));
+            renownUsers: async (parent, args) => {
+                const { driveId, phids, ethAddresses, usernames } = args.input;
+                const resolvedDriveId = getDriveId(driveId);
+                let query = RenownUserProcessor.query(resolvedDriveId, db).selectFrom("renown_user");
+                const hasPhids = phids && phids.length > 0;
+                const hasEthAddresses = ethAddresses && ethAddresses.length > 0;
+                const hasUsernames = usernames && usernames.length > 0;
+                if (!hasPhids && !hasEthAddresses && !hasUsernames) {
+                    throw new Error("At least one of phids, ethAddresses, or usernames must be provided");
                 }
-                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}%`),
-                                ]),
-                            ]
-                            : []),
-                    ]));
+                query = query.where((eb) => {
+                    const conditions = [];
+                    if (hasPhids) {
+                        conditions.push(eb("renown_user.document_id", "in", phids));
+                    }
+                    if (hasEthAddresses) {
+                        conditions.push(eb("renown_user.eth_address", "in", ethAddresses));
+                    }
+                    if (hasUsernames) {
+                        conditions.push(eb("renown_user.username", "in", usernames));
+                    }
+                    return eb.or(conditions);
+                });
+                const results = await query.selectAll().execute();
+                return results.map(mapToUser);
+            },
+            renownCredentials: async (parent, args) => {
+                const { driveId, ethAddress, did, issuer, includeRevoked = true } = args.input;
+                const resolvedDriveId = getDriveId(driveId);
+                let query = RenownCredentialProcessor.query(resolvedDriveId, db).selectFrom("renown_credential");
+                // Search by ethAddress or DID in credential_subject JSON
+                if (ethAddress || did) {
+                    query = query.where((eb) => {
+                        const conditions = [];
+                        if (ethAddress) {
+                            // Search for ethAddress in credential_subject JSON
+                            conditions.push(eb("renown_credential.credential_subject", "like", `%${ethAddress}%`));
+                        }
+                        if (did) {
+                            // Search for DID in credential_subject JSON
+                            conditions.push(eb("renown_credential.credential_subject", "like", `%${did}%`));
+                        }
+                        return eb.or(conditions);
+                    });
                 }
-                else if (searchString) {
-                    query = query.where((eb) => eb.or([
-                        eb("renown_user.username", "like", `%${searchString}%`),
-                        eb("renown_user.eth_address", "like", `%${searchString}%`),
-                    ]));
+                // Filter by issuer if provided
+                if (issuer) {
+                    query = query.where("renown_credential.issuer", "=", issuer);
                 }
-                else {
-                    throw new Error("At least one of ids, usernames, ethAddresses, or searchString must be provided");
+                // Filter by revoked status
+                if (!includeRevoked) {
+                    query = query.where("renown_credential.revoked", "=", false);
                 }
                 const results = await query.selectAll().execute();
-                return results.map(mapToProfile);
+                return results.map(mapToCredential);
             },
         },
     };

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

@@ -3,33 +3,66 @@ export const schema = gql `
   """
   Subgraph definition for Renown Read Model
   """
-  type RenownProfile {
+  type RenownUser {
     documentId: String!
     username: String
     ethAddress: String
     userImage: String
-    createdAt: String
-    updatedAt: String
+    createdAt: DateTime
+    updatedAt: DateTime
   }
 
-  input GetProfileInput {
-    driveId: String!
-    id: String
-    username: String
+  input RenownUserInput {
+    driveId: String
+    phid: String
     ethAddress: String
-    searchInput: String
+    username: String
   }
 
-  input GetProfilesInput {
-    driveId: String!
-    ids: [String!]
-    usernames: [String!]
+  input RenownUsersInput {
+    driveId: String
+    phids: [String!]
     ethAddresses: [String!]
-    searchString: String
+    usernames: [String!]
+  }
+
+  type RenownCredential {
+    documentId: String!
+    credentialId: String
+    context: [String!]!
+    type: [String!]!
+    issuer: String!
+    issuanceDate: DateTime!
+    credentialSubject: String!
+    expirationDate: DateTime
+    credentialStatus: CredentialStatus
+    jwt: String
+    revoked: Boolean!
+    revokedAt: DateTime
+    revocationReason: String
+    createdAt: DateTime
+    updatedAt: DateTime
+  }
+
+  type CredentialStatus {
+    id: String!
+    type: String!
+    statusPurpose: String!
+    statusListIndex: String!
+    statusListCredential: String!
+  }
+
+  input RenownCredentialsInput {
+    driveId: String
+    ethAddress: String
+    did: String
+    issuer: String
+    includeRevoked: Boolean
   }
 
   type Query {
-    getProfile(input: GetProfileInput!): RenownProfile
-    getProfiles(input: GetProfilesInput!): [RenownProfile!]!
+    renownUser(input: RenownUserInput!): RenownUser
+    renownUsers(input: RenownUsersInput!): [RenownUser!]!
+    renownCredentials(input: RenownCredentialsInput!): [RenownCredential!]!
   }
 `;

package/package.json

@@ -1,12 +1,39 @@
 {
   "name": "@powerhousedao/renown-package",
   "description": "",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "AGPL-3.0-only",
   "type": "module",
   "files": [
     "/dist"
   ],
+  "release": {
+    "branches": [
+      "main",
+      {
+        "name": "staging",
+        "prerelease": "staging"
+      },
+      {
+        "name": "dev",
+        "prerelease": "dev"
+      }
+    ],
+    "plugins": [
+      "@semantic-release/changelog",
+      "@semantic-release/git",
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/npm",
+        {
+          "npmPublish": true,
+          "tarballDir": "dist"
+        }
+      ],
+      "@semantic-release/github"
+    ]
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -59,6 +86,8 @@
     "@powerhousedao/reactor-local": "staging",
     "@powerhousedao/scalars": "staging",
     "@powerhousedao/switchboard": "staging",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
     "@tailwindcss/cli": "^4.0.15",
     "@testing-library/react": "^16.3.0",
     "@types/node": "^22.13.11",
@@ -73,6 +102,7 @@
     "pm2": "^5.4.3",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
+    "semantic-release": "^24.2.8",
     "tailwindcss": "^4.1.4",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.30.1",