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

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapIndexerClient = void 0;
+const Attestation_1 = require("../Attestation");
+const Fetcher_1 = require("../Fetcher");
+const entities_1 = require("../entities");
+const GapIndexerApi_1 = require("./api/GapIndexerApi");
+const ProjectMilestone_1 = require("../entities/ProjectMilestone");
+const Endpoints = {
+    attestations: {
+        all: () => "/attestations",
+        byUid: (uid) => `/attestations/${uid}`,
+    },
+    communities: {
+        all: () => "/communities",
+        byUidOrSlug: (uidOrSlug) => `/communities/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/communities/${uidOrSlug}/grants`,
+    },
+    grantees: {
+        all: () => "/grantees",
+        byAddress: (address) => `/grantees/${address}`,
+        grants: (address) => `/grantees/${address}/grants`,
+        projects: (address) => `/grantees/${address}/projects`,
+        communities: (address, withGrants) => `/grantees/${address}/communities${withGrants ? "?withGrants=true" : ""}`,
+        communitiesAdmin: (address, withGrants) => `/grantees/${address}/communities/admin${withGrants ? "?withGrants=true" : ""}`,
+    },
+    grants: {
+        all: () => "/grants",
+        byUid: (uid) => `/grants/${uid}`,
+        byExternalId: (id) => `/grants/external-id/${id}`,
+    },
+    project: {
+        all: () => "/projects",
+        byUidOrSlug: (uidOrSlug) => `/projects/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/projects/${uidOrSlug}/grants`,
+        milestones: (uidOrSlug) => `/projects/${uidOrSlug}/milestones`,
+    },
+};
+class GapIndexerClient extends Fetcher_1.Fetcher {
+    constructor(params) {
+        super(params);
+        this.apiClient = new GapIndexerApi_1.GapIndexerApi(params);
+    }
+    async attestation(uid) {
+        const { data } = await this.apiClient.attestation(uid);
+        if (!data)
+            throw new Error("Attestation not found");
+        return Attestation_1.Attestation.fromInterface([data], this.gap.network)[0];
+    }
+    async attestations(schemaName, search) {
+        const schemaUID = this.gap.findSchema(schemaName).uid;
+        const { data } = await this.apiClient.attestations(schemaUID, search);
+        return data || [];
+    }
+    async attestationsOf(schemaName, attester) {
+        const schemaUID = this.gap.findSchema(schemaName).uid;
+        const { data } = await this.apiClient.attestationsOf(schemaUID, attester);
+        return data || [];
+    }
+    attestationsTo(schemaName, recipient) {
+        return this.attestationsOf(schemaName, recipient);
+    }
+    async communities(search) {
+        const { data } = await this.apiClient.communities(search);
+        return entities_1.Community.from(data, this.gap.network);
+    }
+    async communitiesOf(address, withGrants) {
+        const { data } = await this.apiClient.communitiesOf(address, withGrants);
+        return entities_1.Community.from(data, this.gap.network);
+    }
+    async adminOf(address) {
+        const { data } = await this.apiClient.adminOf(address);
+        return entities_1.Community.from(data, this.gap.network);
+    }
+    async communitiesAdminOf(address, withGrants) {
+        const { data } = await this.client.get(Endpoints.grantees.communitiesAdmin(address, withGrants));
+        return entities_1.Community.from(data, this.gap.network);
+    }
+    communitiesByIds(uids) {
+        throw new Error("Method not implemented.");
+    }
+    async communityBySlug(slug) {
+        const { data } = await this.apiClient.communityBySlug(slug);
+        return entities_1.Community.from([data], this.gap.network)[0];
+    }
+    communityById(uid) {
+        return this.communityBySlug(uid);
+    }
+    async communityAdmins(uid) {
+        const { data } = await this.apiClient.communityAdmins(uid);
+        return data;
+    }
+    async projectBySlug(slug) {
+        const { data } = await this.apiClient.projectBySlug(slug);
+        return entities_1.Project.from([data], this.gap.network)[0];
+    }
+    projectById(uid) {
+        return this.projectBySlug(uid);
+    }
+    async search(query) {
+        const { data } = await this.apiClient.search(query);
+        return { data };
+    }
+    async searchProjects(query) {
+        const { data } = await this.apiClient.searchProjects(query);
+        return entities_1.Project.from(data, this.gap.network);
+    }
+    async projects(name) {
+        const { data } = await this.apiClient.projects(name);
+        return entities_1.Project.from(data, this.gap.network);
+    }
+    async projectsOf(grantee) {
+        const { data } = await this.apiClient.projectsOf(grantee);
+        return entities_1.Project.from(data, this.gap.network);
+    }
+    async projectMilestones(uidOrSlug) {
+        const { data } = await this.apiClient.projectMilestones(uidOrSlug);
+        return ProjectMilestone_1.ProjectMilestone.from(data, this.gap.network);
+    }
+    async grantee(address) {
+        const { data } = await this.apiClient.grantee(address);
+        return data;
+    }
+    async grantees() {
+        const { data } = await this.apiClient.grantees();
+        return data; // TODO: Remove this casting after the api is fixed
+    }
+    async grantsOf(grantee, withCommunity) {
+        const { data } = await this.apiClient.grantsOf(grantee, withCommunity);
+        return entities_1.Grant.from(data, this.gap.network);
+    }
+    async grantsFor(projects, withCommunity) {
+        const { data } = await this.apiClient.grantsFor(projects[0].uid, withCommunity);
+        return entities_1.Grant.from(data, this.gap.network);
+    }
+    async grantsForExtProject(projectExtId) {
+        const { data } = await this.apiClient.grantsForExtProject(projectExtId);
+        return entities_1.Grant.from(data, this.gap.network);
+    }
+    async grantsByCommunity(uid, page = 0, pageLimit = 100) {
+        const { data } = await this.apiClient.grantsByCommunity(uid, page, pageLimit);
+        const grants = data.data;
+        return entities_1.Grant.from(grants, this.gap.network);
+    }
+    async milestonesOf(grants) {
+        const { data } = await this.apiClient.milestonesOf(grants[0].uid);
+        return entities_1.Milestone.from(data, this.gap.network);
+    }
+    async membersOf(projects) {
+        throw new Error("Method not implemented.");
+    }
+    async slugExists(slug) {
+        return await this.apiClient.slugExists(slug);
+    }
+    /**
+     * Track related methods
+     */
+    async getTracks(communityUID, includeArchived = false) {
+        const { data } = await this.apiClient.getTracks(communityUID, includeArchived);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async getTrackById(id) {
+        const { data } = await this.apiClient.getTrackById(id);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async createTrack(trackData) {
+        const { data } = await this.apiClient.createTrack(trackData);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async updateTrack(id, trackData) {
+        const { data } = await this.apiClient.updateTrack(id, trackData);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async archiveTrack(id) {
+        const { data } = await this.apiClient.archiveTrack(id);
+        return entities_1.Track.from([data], this.gap.network)[0];
+    }
+    async assignTracksToProgram(programId, trackIds) {
+        const { data } = await this.apiClient.assignTracksToProgram(programId, trackIds);
+        return data;
+    }
+    async unassignTrackFromProgram(programId, trackId) {
+        const { data } = await this.apiClient.unassignTrackFromProgram(programId, trackId);
+        return data;
+    }
+    async getTracksForProgram(programId) {
+        const { data } = await this.apiClient.getTracksForProgram(programId);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async getTracksForProject(projectId, programId, activeOnly = true) {
+        const { data } = await this.apiClient.getTracksForProject(projectId, programId, activeOnly);
+        return entities_1.Track.from(data, this.gap.network);
+    }
+    async assignTracksToProject(projectId, programId, trackIds) {
+        const { data } = await this.apiClient.assignTracksToProject(projectId, programId, trackIds);
+        return data;
+    }
+    async unassignTracksFromProject(projectId, programId, trackIds) {
+        const { data } = await this.apiClient.unassignTracksFromProject(projectId, programId, trackIds);
+        return data;
+    }
+    async getProjectsByTrack(communityId, programId, trackId) {
+        const { data } = await this.apiClient.getProjectsByTrack(communityId, programId, trackId);
+        return data;
+    }
+}
+exports.GapIndexerClient = GapIndexerClient;

package/core/class/karma-indexer/api/GapIndexerApi.d.ts

@@ -0,0 +1,73 @@
+import { AxiosGQL } from "../../GraphQL/AxiosGQL";
+import { Hex, IAttestationResponse, ICommunityResponse, ICommunityAdminsResponse, IGrantResponse, IProjectResponse, ISearchResponse, IProjectMilestoneResponse, ITrackResponse, ITrackAssignmentResponse, IProjectTrackResponse } from "./types";
+export declare class GapIndexerApi extends AxiosGQL {
+    constructor(url: string);
+    attestation(uid: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse, any>>;
+    attestations(schemaUID: string, search?: string): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
+    attestationsOf(schemaUID: string, attester: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
+    /**
+     * Community
+     */
+    communities(search?: string): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
+    communitiesOf(address: Hex, withGrants: boolean): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
+    adminOf(address: Hex): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
+    communityBySlug(slug: string): Promise<import("axios").AxiosResponse<ICommunityResponse, any>>;
+    communityAdmins(uid: Hex): Promise<import("axios").AxiosResponse<ICommunityAdminsResponse, any>>;
+    /**
+     * Project
+     */
+    projectBySlug(slug: string): Promise<import("axios").AxiosResponse<IProjectResponse, any>>;
+    search(query: string): Promise<import("axios").AxiosResponse<ISearchResponse, any>>;
+    searchProjects(query: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    projects(name?: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    projectsOf(grantee: Hex): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    projectMilestones(uidOrSlug: string): Promise<import("axios").AxiosResponse<IProjectMilestoneResponse[], any>>;
+    /**
+     * Grantee
+     */
+    grantee(address: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    grantees(): Promise<import("axios").AxiosResponse<{
+        [key: `0x${string}`]: {
+            grants: number;
+            projects: number;
+        };
+    }, any>>;
+    /**
+     * Grant
+     */
+    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantsFor(uid: string, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantsForExtProject(projectExtId: string): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantBySlug(slug: Hex): Promise<import("axios").AxiosResponse<IGrantResponse, any>>;
+    grantsByCommunity(uid: Hex, page?: number, pageLimit?: number): Promise<import("axios").AxiosResponse<{
+        data: IGrantResponse[];
+    }, any>>;
+    /**
+     * Milestone
+     */
+    milestonesOf(uid: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    slugExists(slug: string): Promise<boolean>;
+    /**
+     * Tracks
+     */
+    getTracks(communityUID: string, includeArchived?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    getTrackById(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    createTrack(data: {
+        name: string;
+        description?: string;
+        communityUID: string;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    updateTrack(id: string, data: {
+        name?: string;
+        description?: string;
+        communityUID?: string;
+    }): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    archiveTrack(id: string): Promise<import("axios").AxiosResponse<ITrackResponse, any>>;
+    assignTracksToProgram(programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse[], any>>;
+    unassignTrackFromProgram(programId: string, trackId: string): Promise<import("axios").AxiosResponse<ITrackAssignmentResponse, any>>;
+    getTracksForProgram(programId: string): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<import("axios").AxiosResponse<ITrackResponse[], any>>;
+    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
+    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<import("axios").AxiosResponse<any[], any>>;
+    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<import("axios").AxiosResponse<IProjectTrackResponse[], any>>;
+}

package/core/class/karma-indexer/api/GapIndexerApi.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapIndexerApi = void 0;
+const AxiosGQL_1 = require("../../GraphQL/AxiosGQL");
+const Endpoints = {
+    attestations: {
+        all: () => "/attestations",
+        byUid: (uid) => `/attestations/${uid}`,
+    },
+    communities: {
+        all: () => "/communities",
+        admins: (uid) => `/communities/${uid}/admins`,
+        byUidOrSlug: (uidOrSlug) => `/communities/${uidOrSlug}`,
+        grants: (uidOrSlug, page = 0, pageLimit = 100) => `/communities/${uidOrSlug}/grants?${page ? `page=${page}` : ""}${pageLimit ? `&pageLimit=${pageLimit}` : ""}`,
+    },
+    grantees: {
+        all: () => "/grantees",
+        byAddress: (address) => `/grantees/${address}`,
+        grants: (address) => `/grantees/${address}/grants`,
+        projects: (address) => `/grantees/${address}/projects`,
+        communities: (address, withGrants) => `/grantees/${address}/communities${withGrants ? "?withGrants=true" : ""}`,
+        adminOf: (address) => `/grantees/${address}/communities/admin`,
+    },
+    grants: {
+        all: () => "/grants",
+        byUid: (uid) => `/grants/${uid}`,
+        byExternalId: (id) => `/grants/external-id/${id}`,
+    },
+    project: {
+        all: () => "/projects",
+        checkSlug: (slug) => `/projects/check-slug/${slug}`,
+        byUidOrSlug: (uidOrSlug) => `/projects/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/projects/${uidOrSlug}/grants`,
+        milestones: (uidOrSlug) => `/projects/${uidOrSlug}/milestones`,
+        projectMilestones: (uidOrSlug) => `/projects/${uidOrSlug}/project-milestones`,
+    },
+    search: {
+        all: () => "/search",
+    },
+    tracks: {
+        all: () => "/tracks",
+        byId: (id) => `/tracks/${id}`,
+        byCommunity: (communityUID, includeArchived = false) => `/tracks?communityUID=${communityUID}${includeArchived ? "&includeArchived=true" : ""}`,
+    },
+    programs: {
+        tracks: {
+            all: (programId) => `/programs/${programId}/tracks`,
+            assign: (programId) => `/programs/${programId}/tracks`,
+            remove: (programId, trackId) => `/programs/${programId}/tracks/${trackId}`,
+        },
+    },
+    projectTracks: {
+        all: (projectId, programId, activeOnly = true) => `/programs/${programId}/projects/${projectId}/tracks${activeOnly ? "" : "?activeOnly=false"}`,
+        assign: (projectId) => `/projects/${projectId}/tracks`,
+        remove: (programId, projectId) => `/programs/${programId}/project/${projectId}/tracks`,
+    },
+    community: {
+        programProjects: (communityId, programId, trackId) => `/community/${communityId}/program/${programId}/projects${trackId ? `?trackId=${trackId}` : ""}`,
+    },
+};
+class GapIndexerApi extends AxiosGQL_1.AxiosGQL {
+    constructor(url) {
+        super(url);
+    }
+    async attestation(uid) {
+        const response = await this.client.get(Endpoints.attestations.byUid(uid));
+        return response;
+    }
+    async attestations(schemaUID, search) {
+        const response = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": schemaUID,
+                "filter[data]": search,
+            },
+        });
+        return response;
+    }
+    async attestationsOf(schemaUID, attester) {
+        const response = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": schemaUID,
+                "filter[recipient]": attester,
+            },
+        });
+        return response;
+    }
+    /**
+     * Community
+     */
+    async communities(search) {
+        const response = await this.client.get(Endpoints.communities.all(), {
+            params: {
+                "filter[name]": search,
+            },
+        });
+        return response;
+    }
+    async communitiesOf(address, withGrants) {
+        const response = await this.client.get(Endpoints.grantees.communities(address, withGrants));
+        return response;
+    }
+    async adminOf(address) {
+        const response = await this.client.get(Endpoints.grantees.adminOf(address));
+        return response;
+    }
+    async communityBySlug(slug) {
+        const response = await this.client.get(Endpoints.communities.byUidOrSlug(slug));
+        return response;
+    }
+    async communityAdmins(uid) {
+        const response = await this.client.get(Endpoints.communities.admins(uid));
+        return response;
+    }
+    /**
+     * Project
+     */
+    async projectBySlug(slug) {
+        const response = await this.client.get(Endpoints.project.byUidOrSlug(slug));
+        return response;
+    }
+    async search(query) {
+        const response = await this.client.get(Endpoints.search.all(), {
+            params: {
+                q: query,
+            },
+        });
+        return response;
+    }
+    async searchProjects(query) {
+        const response = await this.client.get(Endpoints.project.all(), {
+            params: {
+                q: query,
+            },
+        });
+        return response;
+    }
+    async projects(name) {
+        const response = await this.client.get(Endpoints.project.all(), {
+            params: {
+                "filter[title]": name,
+            },
+        });
+        return response;
+    }
+    async projectsOf(grantee) {
+        const response = await this.client.get(Endpoints.grantees.projects(grantee));
+        return response;
+    }
+    async projectMilestones(uidOrSlug) {
+        const response = await this.client.get(Endpoints.project.projectMilestones(uidOrSlug));
+        return response;
+    }
+    /**
+     * Grantee
+     */
+    async grantee(address) {
+        // TODO: update response type when the endpoint works
+        const response = await this.client.get(Endpoints.grantees.byAddress(address));
+        return response;
+    }
+    async grantees() {
+        const response = await this.client.get(Endpoints.grantees.all());
+        return response;
+    }
+    /**
+     * Grant
+     */
+    async grantsOf(grantee, withCommunity) {
+        const response = await this.client.get(Endpoints.grantees.grants(grantee));
+        return response;
+    }
+    async grantsFor(uid, withCommunity) {
+        const response = await this.client.get(Endpoints.project.grants(uid));
+        return response;
+    }
+    async grantsForExtProject(projectExtId) {
+        const response = await this.client.get(Endpoints.grants.byExternalId(projectExtId));
+        return response;
+    }
+    async grantBySlug(slug) {
+        const response = await this.client.get(Endpoints.grants.byUid(slug));
+        return response;
+    }
+    async grantsByCommunity(uid, page = 0, pageLimit = 100) {
+        const response = await this.client.get(Endpoints.communities.grants(uid, page, pageLimit));
+        return response;
+    }
+    /**
+     * Milestone
+     */
+    async milestonesOf(uid) {
+        const response = await this.client.get(Endpoints.project.milestones(uid));
+        return response;
+    }
+    async slugExists(slug) {
+        try {
+            await this.client.get(Endpoints.project.checkSlug(slug));
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    /**
+     * Tracks
+     */
+    async getTracks(communityUID, includeArchived = false) {
+        const response = await this.client.get(Endpoints.tracks.byCommunity(communityUID, includeArchived));
+        return response;
+    }
+    async getTrackById(id) {
+        const response = await this.client.get(Endpoints.tracks.byId(id));
+        return response;
+    }
+    async createTrack(data) {
+        const response = await this.client.post(Endpoints.tracks.all(), data);
+        return response;
+    }
+    async updateTrack(id, data) {
+        const response = await this.client.put(Endpoints.tracks.byId(id), data);
+        return response;
+    }
+    async archiveTrack(id) {
+        const response = await this.client.delete(Endpoints.tracks.byId(id));
+        return response;
+    }
+    async assignTracksToProgram(programId, trackIds) {
+        const response = await this.client.post(Endpoints.programs.tracks.assign(programId), { trackIds });
+        return response;
+    }
+    async unassignTrackFromProgram(programId, trackId) {
+        const response = await this.client.delete(Endpoints.programs.tracks.remove(programId, trackId));
+        return response;
+    }
+    async getTracksForProgram(programId) {
+        const response = await this.client.get(Endpoints.programs.tracks.all(programId));
+        return response;
+    }
+    async getTracksForProject(projectId, programId, activeOnly = true) {
+        const response = await this.client.get(Endpoints.projectTracks.all(projectId, programId, activeOnly));
+        return response;
+    }
+    async assignTracksToProject(projectId, programId, trackIds) {
+        const response = await this.client.post(Endpoints.projectTracks.assign(projectId), { trackIds, programId });
+        return response;
+    }
+    async unassignTracksFromProject(projectId, programId, trackIds) {
+        const response = await this.client.delete(Endpoints.projectTracks.remove(programId, projectId), { data: { trackIds } });
+        return response;
+    }
+    async getProjectsByTrack(communityId, programId, trackId) {
+        const response = await this.client.get(Endpoints.community.programProjects(communityId, programId, trackId));
+        return response;
+    }
+}
+exports.GapIndexerApi = GapIndexerApi;