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

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

@@ -1,207 +0,0 @@
-"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

@@ -1,73 +0,0 @@
-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

@@ -1,256 +0,0 @@
-"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;