@show-karma/karma-gap-sdk 0.4.14 → 0.4.16

package/core/class/karma-indexer/GapIndexerClient.ts

@@ -0,0 +1,383 @@
+import { TSchemaName, IAttestation, TNetwork, Hex } from "core/types";
+import { Attestation } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { Fetcher } from "../Fetcher";
+import {
+  Community,
+  Project,
+  Grant,
+  Milestone,
+  MemberOf,
+  Track,
+} from "../entities";
+import { Grantee } from "../types/attestations";
+import { GapIndexerApi } from "./api/GapIndexerApi";
+import { ICommunityAdminsResponse, ICommunityResponse } from "./api/types";
+import { ProjectMilestone } from "../entities/ProjectMilestone";
+
+const Endpoints = {
+  attestations: {
+    all: () => "/attestations",
+    byUid: (uid: Hex) => `/attestations/${uid}`,
+  },
+  communities: {
+    all: () => "/communities",
+    byUidOrSlug: (uidOrSlug: string) => `/communities/${uidOrSlug}`,
+    grants: (uidOrSlug: string) => `/communities/${uidOrSlug}/grants`,
+  },
+  grantees: {
+    all: () => "/grantees",
+    byAddress: (address: Hex) => `/grantees/${address}`,
+    grants: (address: Hex) => `/grantees/${address}/grants`,
+    projects: (address: Hex) => `/grantees/${address}/projects`,
+    communities: (address: Hex, withGrants) =>
+      `/grantees/${address}/communities${withGrants ? "?withGrants=true" : ""}`,
+    communitiesAdmin: (address: Hex, withGrants) =>
+      `/grantees/${address}/communities/admin${
+        withGrants ? "?withGrants=true" : ""
+      }`,
+  },
+  grants: {
+    all: () => "/grants",
+    byUid: (uid: Hex) => `/grants/${uid}`,
+    byExternalId: (id: string) => `/grants/external-id/${id}`,
+  },
+  project: {
+    all: () => "/projects",
+    byUidOrSlug: (uidOrSlug: string) => `/projects/${uidOrSlug}`,
+    grants: (uidOrSlug: string) => `/projects/${uidOrSlug}/grants`,
+    milestones: (uidOrSlug: string) => `/projects/${uidOrSlug}/milestones`,
+  },
+};
+
+export class GapIndexerClient extends Fetcher {
+  private apiClient: GapIndexerApi;
+  constructor(params) {
+    super(params);
+    this.apiClient = new GapIndexerApi(params);
+  }
+
+  async attestation<T = unknown>(
+    uid: `0x${string}`
+  ): Promise<Attestation<T, GapSchema>> {
+    const { data } = await this.apiClient.attestation(uid);
+
+    if (!data) throw new Error("Attestation not found");
+    return Attestation.fromInterface<Attestation<T>>(
+      [data],
+      this.gap.network
+    )[0];
+  }
+
+  async attestations(
+    schemaName: TSchemaName,
+    search?: string
+  ): Promise<IAttestation[]> {
+    const schemaUID = this.gap.findSchema(schemaName).uid;
+    const { data } = await this.apiClient.attestations(schemaUID, search);
+
+    return data || [];
+  }
+
+  async attestationsOf(
+    schemaName: TSchemaName,
+    attester: `0x${string}`
+  ): Promise<IAttestation[]> {
+    const schemaUID = this.gap.findSchema(schemaName).uid;
+    const { data } = await this.apiClient.attestationsOf(schemaUID, attester);
+
+    return data || [];
+  }
+
+  attestationsTo(
+    schemaName: TSchemaName,
+    recipient: `0x${string}`
+  ): Promise<IAttestation[]> {
+    return this.attestationsOf(schemaName, recipient);
+  }
+
+  async communities(search?: string): Promise<Community[]> {
+    const { data } = await this.apiClient.communities(search);
+
+    return Community.from(data, this.gap.network);
+  }
+
+  async communitiesOf(address: Hex, withGrants: boolean): Promise<Community[]> {
+    const { data } = await this.apiClient.communitiesOf(address, withGrants);
+
+    return Community.from(data, this.gap.network);
+  }
+
+  async adminOf(address: Hex): Promise<Community[]> {
+    const { data } = await this.apiClient.adminOf(address);
+
+    return Community.from(data, this.gap.network);
+  }
+
+  async communitiesAdminOf(
+    address: Hex,
+    withGrants: boolean
+  ): Promise<Community[]> {
+    const { data } = await this.client.get<Community[]>(
+      Endpoints.grantees.communitiesAdmin(address, withGrants)
+    );
+
+    return Community.from(
+      data as any as ICommunityResponse[],
+      this.gap.network
+    );
+  }
+
+  communitiesByIds(uids: `0x${string}`[]): Promise<Community[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  async communityBySlug(slug: string): Promise<Community> {
+    const { data } = await this.apiClient.communityBySlug(slug);
+
+    return Community.from([data], this.gap.network)[0];
+  }
+
+  communityById(uid: `0x${string}`): Promise<Community> {
+    return this.communityBySlug(uid);
+  }
+
+  async communityAdmins(uid: `0x${string}`): Promise<ICommunityAdminsResponse> {
+    const { data } = await this.apiClient.communityAdmins(uid);
+    return data;
+  }
+
+  async projectBySlug(slug: string): Promise<Project> {
+    const { data } = await this.apiClient.projectBySlug(slug);
+
+    return Project.from([data], this.gap.network)[0];
+  }
+
+  projectById(uid: `0x${string}`): Promise<Project> {
+    return this.projectBySlug(uid);
+  }
+
+  async search(
+    query: string
+  ): Promise<{ projects: Project[]; communities: Community[] }> {
+    const { data } = await this.apiClient.search(query);
+
+    return { data } as unknown as {
+      projects: Project[];
+      communities: Community[];
+    };
+  }
+
+  async searchProjects(query: string): Promise<Project[]> {
+    const { data } = await this.apiClient.searchProjects(query);
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async projects(name?: string): Promise<Project[]> {
+    const { data } = await this.apiClient.projects(name);
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async projectsOf(grantee: `0x${string}`): Promise<Project[]> {
+    const { data } = await this.apiClient.projectsOf(grantee);
+
+    return Project.from(data, this.gap.network);
+  }
+
+  async projectMilestones(uidOrSlug: string): Promise<ProjectMilestone[]> {
+    const { data } = await this.apiClient.projectMilestones(uidOrSlug);
+
+    return ProjectMilestone.from(data, this.gap.network);
+  }
+
+  async grantee(address: `0x${string}`): Promise<Grantee> {
+    const { data } = await this.apiClient.grantee(address);
+
+    return data as Grantee;
+  }
+
+  async grantees(): Promise<Grantee[]> {
+    const { data } = await this.apiClient.grantees();
+
+    return data as any as Grantee[]; // TODO: Remove this casting after the api is fixed
+  }
+
+  async grantsOf(
+    grantee: `0x${string}`,
+    withCommunity?: boolean
+  ): Promise<Grant[]> {
+    const { data } = await this.apiClient.grantsOf(grantee, withCommunity);
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsFor(
+    projects: Project[],
+    withCommunity?: boolean
+  ): Promise<Grant[]> {
+    const { data } = await this.apiClient.grantsFor(
+      projects[0].uid,
+      withCommunity
+    );
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsForExtProject(projectExtId: string): Promise<Grant[]> {
+    const { data } = await this.apiClient.grantsForExtProject(projectExtId);
+
+    return Grant.from(data, this.gap.network);
+  }
+
+  async grantsByCommunity(
+    uid: `0x${string}`,
+    page: number = 0,
+    pageLimit: number = 100
+  ) {
+    const { data } = await this.apiClient.grantsByCommunity(
+      uid,
+      page,
+      pageLimit
+    );
+    const grants = data.data;
+
+    return Grant.from(grants, this.gap.network);
+  }
+
+  async milestonesOf(grants: Grant[]): Promise<Milestone[]> {
+    const { data } = await this.apiClient.milestonesOf(grants[0].uid);
+
+    return Milestone.from(data, this.gap.network);
+  }
+
+  async membersOf(projects: Project[]): Promise<MemberOf[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  async slugExists(slug: string): Promise<boolean> {
+    return await this.apiClient.slugExists(slug);
+  }
+
+  /**
+   * Track related methods
+   */
+
+  async getTracks(
+    communityUID: string,
+    includeArchived: boolean = false
+  ): Promise<Track[]> {
+    const { data } = await this.apiClient.getTracks(
+      communityUID,
+      includeArchived
+    );
+    return Track.from(data, this.gap.network);
+  }
+
+  async getTrackById(id: string): Promise<Track> {
+    const { data } = await this.apiClient.getTrackById(id);
+    return Track.from([data], this.gap.network)[0];
+  }
+
+  async createTrack(trackData: {
+    name: string;
+    description?: string;
+    communityUID: string;
+  }): Promise<Track> {
+    const { data } = await this.apiClient.createTrack(trackData);
+    return Track.from([data], this.gap.network)[0];
+  }
+
+  async updateTrack(
+    id: string,
+    trackData: { name?: string; description?: string; communityUID?: string }
+  ): Promise<Track> {
+    const { data } = await this.apiClient.updateTrack(id, trackData);
+    return Track.from([data], this.gap.network)[0];
+  }
+
+  async archiveTrack(id: string): Promise<Track> {
+    const { data } = await this.apiClient.archiveTrack(id);
+    return Track.from([data], this.gap.network)[0];
+  }
+
+  async assignTracksToProgram(
+    programId: string,
+    trackIds: string[]
+  ): Promise<any[]> {
+    const { data } = await this.apiClient.assignTracksToProgram(
+      programId,
+      trackIds
+    );
+    return data;
+  }
+
+  async unassignTrackFromProgram(
+    programId: string,
+    trackId: string
+  ): Promise<any> {
+    const { data } = await this.apiClient.unassignTrackFromProgram(
+      programId,
+      trackId
+    );
+    return data;
+  }
+
+  async getTracksForProgram(programId: string): Promise<Track[]> {
+    const { data } = await this.apiClient.getTracksForProgram(programId);
+    return Track.from(data, this.gap.network);
+  }
+
+  async getTracksForProject(
+    projectId: string,
+    programId: string,
+    activeOnly: boolean = true
+  ): Promise<Track[]> {
+    const { data } = await this.apiClient.getTracksForProject(
+      projectId,
+      programId,
+      activeOnly
+    );
+    return Track.from(data, this.gap.network);
+  }
+
+  async assignTracksToProject(
+    projectId: string,
+    programId: string,
+    trackIds: string[]
+  ): Promise<any[]> {
+    const { data } = await this.apiClient.assignTracksToProject(
+      projectId,
+      programId,
+      trackIds
+    );
+    return data;
+  }
+
+  async unassignTracksFromProject(
+    projectId: string,
+    programId: string,
+    trackIds: string[]
+  ): Promise<any[]> {
+    const { data } = await this.apiClient.unassignTracksFromProject(
+      projectId,
+      programId,
+      trackIds
+    );
+    return data;
+  }
+
+  async getProjectsByTrack(
+    communityId: string,
+    programId: string,
+    trackId?: string
+  ): Promise<any[]> {
+    const { data } = await this.apiClient.getProjectsByTrack(
+      communityId,
+      programId,
+      trackId
+    );
+    return data;
+  }
+}