@powerhousedao/network-admin 0.0.40 → 0.0.42

package/dist/editors/request-for-proposals/editor.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { actions, } from "../../document-models/request-for-proposals/index.js";
 import { DatePicker, Select, TextInput, NumberInput, } from "@powerhousedao/document-engineering";
 import { toast, ToastContainer } from "@powerhousedao/design-system/connect";
-import { MarkdownEditor } from "./markdown-editor.jsx";
+import { MarkdownEditor } from "./markdown-editor.js";
 import { useSelectedRequestForProposalsDocument } from "../../document-models/request-for-proposals/hooks.js";
 import { DocumentToolbar } from "@powerhousedao/design-system/connect";
 import { setSelectedNode, useParentFolderForSelectedNode, } from "@powerhousedao/reactor-browser";

package/dist/scripts/sow-mirror/mirror_sow_state.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=mirror_sow_state.d.ts.map

package/dist/scripts/sow-mirror/mirror_sow_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror_sow_state.d.ts","sourceRoot":"","sources":["../../../scripts/sow-mirror/mirror_sow_state.ts"],"names":[],"mappings":""}

package/dist/scripts/sow-mirror/mirror_sow_state.js

@@ -0,0 +1,441 @@
+#!/usr/bin/env bun
+// Parse command line arguments
+const args = process.argv.slice(2);
+if (args.length !== 6) {
+    console.error('Usage: bun mirror_sow_state.ts <remote-mcp-url> <remote-sow-id> <remote-drive-id> <local-mcp-url> <local-sow-id> <local-drive-id>');
+    console.error('');
+    console.error('Example:');
+    console.error('  bun mirror_sow_state.ts \\');
+    console.error('    https://switchboard-dev.powerhouse.xyz/mcp \\');
+    console.error('    65f3e7e8-500d-4c42-9e73-8cd5d7966cd8 \\');
+    console.error('    powerhouse-network-admin \\');
+    console.error('    http://localhost:4001/mcp \\');
+    console.error('    3471233d-c481-4214-afe3-c196b5a7778f \\');
+    console.error('    bai-network-admin');
+    process.exit(1);
+}
+const [REMOTE_MCP_URL, REMOTE_DOC_ID, REMOTE_DRIVE_ID, LOCAL_MCP_URL, LOCAL_DOC_ID, LOCAL_DRIVE_ID] = args;
+// Helper function to make MCP requests
+async function mcpRequest(url, payload) {
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream'
+        },
+        body: JSON.stringify(payload)
+    });
+    const text = await response.text();
+    // Handle SSE format (event: message\ndata: {...})
+    if (text.includes('event: message')) {
+        const lines = text.split('\n');
+        const dataLine = lines.find(line => line.startsWith('data: '));
+        if (dataLine) {
+            const jsonData = dataLine.substring(6);
+            return JSON.parse(jsonData);
+        }
+        throw new Error('No data line found in SSE response');
+    }
+    return JSON.parse(text);
+}
+// Fetch remote document
+async function getRemoteDocument() {
+    console.log(`Fetching remote document (${REMOTE_DOC_ID}) from drive "${REMOTE_DRIVE_ID}"...`);
+    const payload = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        params: {
+            name: 'getDocument',
+            arguments: { id: REMOTE_DOC_ID }
+        },
+        id: 1
+    };
+    const response = await mcpRequest(REMOTE_MCP_URL, payload);
+    if (response.error) {
+        throw new Error(`Remote fetch error: ${JSON.stringify(response.error)}`);
+    }
+    return response.result.structuredContent.document;
+}
+// Get current local document state
+async function getLocalDocument() {
+    console.log(`Fetching local document (${LOCAL_DOC_ID}) from drive "${LOCAL_DRIVE_ID}"...`);
+    const payload = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        params: {
+            name: 'getDocument',
+            arguments: { id: LOCAL_DOC_ID }
+        },
+        id: 2
+    };
+    const response = await mcpRequest(LOCAL_MCP_URL, payload);
+    if (response.error) {
+        throw new Error(`Local fetch error: ${JSON.stringify(response.error)}`);
+    }
+    return response.result.structuredContent.document;
+}
+// Generate actions to mirror remote state
+function generateActions(remoteState, localState) {
+    const actions = [];
+    // 1. Update basic scope of work details
+    if (remoteState.title !== localState.title ||
+        remoteState.description !== localState.description ||
+        remoteState.status !== localState.status) {
+        actions.push({
+            type: 'EDIT_SCOPE_OF_WORK',
+            scope: 'global',
+            input: {
+                title: remoteState.title,
+                description: remoteState.description,
+                status: remoteState.status
+            }
+        });
+    }
+    // 2. Add missing contributors
+    const localContributorIds = new Set(localState.contributors.map((c) => c.id));
+    remoteState.contributors.forEach((contributor) => {
+        if (!localContributorIds.has(contributor.id)) {
+            const input = {
+                id: contributor.id,
+                name: contributor.name
+            };
+            if (contributor.icon)
+                input.icon = contributor.icon;
+            if (contributor.description)
+                input.description = contributor.description;
+            actions.push({
+                type: 'ADD_AGENT',
+                scope: 'global',
+                input
+            });
+        }
+    });
+    // 3. Add missing deliverables with all their data
+    const localDeliverableIds = new Set(localState.deliverables.map((d) => d.id));
+    remoteState.deliverables.forEach((deliverable) => {
+        if (!localDeliverableIds.has(deliverable.id)) {
+            // Add deliverable
+            actions.push({
+                type: 'ADD_DELIVERABLE',
+                scope: 'global',
+                input: {
+                    id: deliverable.id,
+                    owner: deliverable.owner || undefined,
+                    title: deliverable.title,
+                    code: deliverable.code,
+                    description: deliverable.description,
+                    status: deliverable.status
+                }
+            });
+            // Set work progress
+            if (deliverable.workProgress) {
+                const progressInput = {};
+                if (deliverable.workProgress.value !== undefined) {
+                    progressInput.percentage = deliverable.workProgress.value;
+                }
+                else if (deliverable.workProgress.total !== undefined) {
+                    progressInput.storyPoints = {
+                        total: deliverable.workProgress.total,
+                        completed: deliverable.workProgress.completed
+                    };
+                }
+                else if (deliverable.workProgress.done !== undefined) {
+                    progressInput.done = deliverable.workProgress.done;
+                }
+                if (Object.keys(progressInput).length > 0) {
+                    actions.push({
+                        type: 'SET_DELIVERABLE_PROGRESS',
+                        scope: 'global',
+                        input: {
+                            id: deliverable.id,
+                            workProgress: progressInput
+                        }
+                    });
+                }
+            }
+            // Add key results
+            if (deliverable.keyResults && deliverable.keyResults.length > 0) {
+                deliverable.keyResults.forEach((kr) => {
+                    actions.push({
+                        type: 'ADD_KEY_RESULT',
+                        scope: 'global',
+                        input: {
+                            id: kr.id,
+                            deliverableId: deliverable.id,
+                            title: kr.title,
+                            link: kr.link
+                        }
+                    });
+                });
+            }
+            // Set budget anchor if exists
+            if (deliverable.budgetAnchor && deliverable.budgetAnchor.project) {
+                actions.push({
+                    type: 'SET_DELIVERABLE_BUDGET_ANCHOR_PROJECT',
+                    scope: 'global',
+                    input: {
+                        deliverableId: deliverable.id,
+                        project: deliverable.budgetAnchor.project,
+                        unit: deliverable.budgetAnchor.unit,
+                        unitCost: deliverable.budgetAnchor.unitCost,
+                        quantity: deliverable.budgetAnchor.quantity,
+                        margin: deliverable.budgetAnchor.margin
+                    }
+                });
+            }
+        }
+    });
+    // 4. Add projects if any
+    if (remoteState.projects && remoteState.projects.length > 0) {
+        const localProjectsMap = new Map(localState.projects.map((p) => [p.id, p]));
+        remoteState.projects.forEach((project) => {
+            const localProject = localProjectsMap.get(project.id);
+            if (!localProject) {
+                // Project doesn't exist, add it
+                actions.push({
+                    type: 'ADD_PROJECT',
+                    scope: 'global',
+                    input: {
+                        id: project.id,
+                        code: project.code,
+                        title: project.title,
+                        projectOwner: project.projectOwner || undefined,
+                        abstract: project.abstract || undefined,
+                        imageUrl: project.imageUrl || undefined,
+                        budgetType: project.budgetType || undefined,
+                        currency: project.currency || undefined,
+                        budget: project.budget || 0
+                    }
+                });
+            }
+            // Add missing deliverables to project scope
+            if (project.scope && project.scope.deliverables && project.scope.deliverables.length > 0) {
+                const localDeliverables = new Set(((localProject)?.scope?.deliverables) || []);
+                project.scope.deliverables.forEach((deliverableId) => {
+                    if (!localDeliverables.has(deliverableId)) {
+                        const deliverable = remoteState.deliverables.find((d) => d.id === deliverableId);
+                        if (deliverable) {
+                            actions.push({
+                                type: 'ADD_DELIVERABLE_IN_SET',
+                                scope: 'global',
+                                input: {
+                                    projectId: project.id,
+                                    deliverableId: deliverableId
+                                }
+                            });
+                        }
+                    }
+                });
+                // Set project scope metadata (status and deliverablesCompleted)
+                if (project.scope.status || project.scope.deliverablesCompleted) {
+                    actions.push({
+                        type: 'EDIT_DELIVERABLES_SET',
+                        scope: 'global',
+                        input: {
+                            projectId: project.id,
+                            status: project.scope.status || undefined,
+                            deliverablesCompleted: project.scope.deliverablesCompleted || undefined
+                        }
+                    });
+                }
+            }
+        });
+    }
+    // 5. Add roadmaps if any
+    if (remoteState.roadmaps && remoteState.roadmaps.length > 0) {
+        const localRoadmapIds = new Set(localState.roadmaps.map((r) => r.id));
+        const localRoadmapsMap = new Map(localState.roadmaps.map((r) => [r.id, r]));
+        remoteState.roadmaps.forEach((roadmap) => {
+            const localRoadmap = localRoadmapsMap.get(roadmap.id);
+            if (!localRoadmap) {
+                actions.push({
+                    type: 'ADD_ROADMAP',
+                    scope: 'global',
+                    input: {
+                        id: roadmap.id,
+                        title: roadmap.title,
+                        slug: roadmap.slug || undefined,
+                        description: roadmap.description || undefined
+                    }
+                });
+            }
+            // Add milestones for this roadmap
+            if (roadmap.milestones && roadmap.milestones.length > 0) {
+                const localMilestonesMap = new Map(((localRoadmap)?.milestones || []).map((m) => [m.id, m]));
+                roadmap.milestones.forEach((milestone) => {
+                    const localMilestone = localMilestonesMap.get(milestone.id);
+                    if (!localMilestone) {
+                        actions.push({
+                            type: 'ADD_MILESTONE',
+                            scope: 'global',
+                            input: {
+                                id: milestone.id,
+                                roadmapId: roadmap.id,
+                                sequenceCode: milestone.sequenceCode || undefined,
+                                title: milestone.title,
+                                description: milestone.description || undefined,
+                                deliveryTarget: milestone.deliveryTarget || undefined
+                            }
+                        });
+                    }
+                    // Add coordinators for milestone
+                    if (milestone.coordinators && milestone.coordinators.length > 0) {
+                        const localCoordinators = new Set((localMilestone)?.coordinators || []);
+                        milestone.coordinators.forEach((coordinatorId) => {
+                            if (!localCoordinators.has(coordinatorId)) {
+                                actions.push({
+                                    type: 'ADD_COORDINATOR',
+                                    scope: 'global',
+                                    input: {
+                                        id: coordinatorId,
+                                        milestoneId: milestone.id
+                                    }
+                                });
+                            }
+                        });
+                    }
+                    // Add deliverables to milestone
+                    if (milestone.scope && milestone.scope.deliverables && milestone.scope.deliverables.length > 0) {
+                        const localMilestoneDeliverables = new Set(((localMilestone)?.scope?.deliverables) || []);
+                        milestone.scope.deliverables.forEach((deliverableId) => {
+                            if (!localMilestoneDeliverables.has(deliverableId)) {
+                                actions.push({
+                                    type: 'ADD_DELIVERABLE_IN_SET',
+                                    scope: 'global',
+                                    input: {
+                                        milestoneId: milestone.id,
+                                        deliverableId: deliverableId
+                                    }
+                                });
+                            }
+                        });
+                        // Set milestone scope metadata
+                        if (milestone.scope.status || milestone.scope.deliverablesCompleted) {
+                            actions.push({
+                                type: 'EDIT_DELIVERABLES_SET',
+                                scope: 'global',
+                                input: {
+                                    milestoneId: milestone.id,
+                                    status: milestone.scope.status || undefined,
+                                    deliverablesCompleted: milestone.scope.deliverablesCompleted || undefined
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        });
+    }
+    return actions;
+}
+// Send actions in batches
+async function sendActions(actions) {
+    const BATCH_SIZE = 50;
+    const batches = [];
+    for (let i = 0; i < actions.length; i += BATCH_SIZE) {
+        batches.push(actions.slice(i, i + BATCH_SIZE));
+    }
+    console.log(`\nSending ${actions.length} actions in ${batches.length} batches...`);
+    for (let i = 0; i < batches.length; i++) {
+        const batch = batches[i];
+        console.log(`\nBatch ${i + 1}/${batches.length} (${batch.length} actions)...`);
+        const payload = {
+            jsonrpc: '2.0',
+            method: 'tools/call',
+            params: {
+                name: 'addActions',
+                arguments: {
+                    documentId: LOCAL_DOC_ID,
+                    actions: batch
+                }
+            },
+            id: 1000 + i
+        };
+        try {
+            const response = await mcpRequest(LOCAL_MCP_URL, payload);
+            if (response.error) {
+                console.error(`Error in batch ${i + 1}:`, JSON.stringify(response.error, null, 2));
+                throw new Error(`Batch ${i + 1} failed`);
+            }
+            console.log(`✓ Batch ${i + 1} completed successfully`);
+        }
+        catch (error) {
+            console.error(`Failed to send batch ${i + 1}:`, error);
+            throw error;
+        }
+    }
+}
+// Main function
+async function main() {
+    try {
+        console.log('='.repeat(70));
+        console.log('Scope of Work State-Based Mirror Script');
+        console.log('='.repeat(70));
+        console.log('\nConfiguration:');
+        console.log(`  Remote MCP: ${REMOTE_MCP_URL}`);
+        console.log(`  Remote Drive: ${REMOTE_DRIVE_ID}`);
+        console.log(`  Remote SoW ID: ${REMOTE_DOC_ID}`);
+        console.log(`  Local MCP: ${LOCAL_MCP_URL}`);
+        console.log(`  Local Drive: ${LOCAL_DRIVE_ID}`);
+        console.log(`  Local SoW ID: ${LOCAL_DOC_ID}`);
+        console.log('');
+        // Fetch remote document
+        const remoteDoc = await getRemoteDocument();
+        const remoteState = remoteDoc.state.global;
+        console.log(`✓ Remote document fetched: "${remoteState.title}"`);
+        console.log(`  - Status: ${remoteState.status}`);
+        console.log(`  - Contributors: ${remoteState.contributors.length}`);
+        console.log(`  - Deliverables: ${remoteState.deliverables.length}`);
+        console.log(`  - Projects: ${remoteState.projects.length}`);
+        console.log(`  - Roadmaps: ${remoteState.roadmaps.length}`);
+        // Fetch local document
+        const localDoc = await getLocalDocument();
+        const localState = localDoc.state.global;
+        console.log(`\n✓ Local document fetched: "${localState.title}"`);
+        console.log(`  - Status: ${localState.status}`);
+        console.log(`  - Contributors: ${localState.contributors.length}`);
+        console.log(`  - Deliverables: ${localState.deliverables.length}`);
+        console.log(`  - Projects: ${localState.projects.length}`);
+        console.log(`  - Roadmaps: ${localState.roadmaps.length}`);
+        // Generate actions
+        console.log('\nGenerating actions to mirror remote state...');
+        const actions = generateActions(remoteState, localState);
+        console.log(`✓ Generated ${actions.length} actions`);
+        if (actions.length === 0) {
+            console.log('\n✓ Documents are already in sync!');
+            return;
+        }
+        // Show action summary
+        const actionTypes = {};
+        actions.forEach(action => {
+            actionTypes[action.type] = (actionTypes[action.type] || 0) + 1;
+        });
+        console.log('\nAction summary:');
+        Object.entries(actionTypes).forEach(([type, count]) => {
+            console.log(`  - ${type}: ${count}`);
+        });
+        // Send actions
+        await sendActions(actions);
+        // Verify final state
+        console.log('\nVerifying final state...');
+        const finalLocalDoc = await getLocalDocument();
+        const finalLocalState = finalLocalDoc.state.global;
+        console.log(`✓ Final local document state:`);
+        console.log(`  - Title: "${finalLocalState.title}"`);
+        console.log(`  - Status: ${finalLocalState.status}`);
+        console.log(`  - Contributors: ${finalLocalState.contributors.length}`);
+        console.log(`  - Deliverables: ${finalLocalState.deliverables.length}`);
+        console.log(`  - Projects: ${finalLocalState.projects.length}`);
+        console.log(`  - Roadmaps: ${finalLocalState.roadmaps.length}`);
+        console.log('\n' + '='.repeat(70));
+        console.log('✓ Mirror complete!');
+        console.log('='.repeat(70));
+    }
+    catch (error) {
+        console.error('\n✗ Error:', error);
+        process.exit(1);
+    }
+}
+// Run the script
+main();
+export {};

package/dist/subgraphs/index.d.ts

@@ -1,3 +1,8 @@
 export {};
 export * as NetworkProfileSubgraph from "./network-profile/index.js";
+export * as PaymentTermsSubgraph from "./payment-terms/index.js";
+export * as RequestForProposalsSubgraph from "./request-for-proposals/index.js";
+export * as WorkstreamSubgraph from "./workstream/index.js";
+export * as WorkstreamsSubgraph from "./workstreams/index.js";
+export * as NetworksSubgraph from "./networks/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/subgraphs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../subgraphs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,CAAC;AACX,OAAO,KAAK,sBAAsB,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../subgraphs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC;AACV,OAAO,KAAK,sBAAsB,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,oBAAoB,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,2BAA2B,MAAM,kCAAkC,CAAC;AAChF,OAAO,KAAK,kBAAkB,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,mBAAmB,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,gBAAgB,MAAM,qBAAqB,CAAC"}

package/dist/subgraphs/index.js

@@ -1,2 +1,7 @@
 export {};
 export * as NetworkProfileSubgraph from "./network-profile/index.js";
+export * as PaymentTermsSubgraph from "./payment-terms/index.js";
+export * as RequestForProposalsSubgraph from "./request-for-proposals/index.js";
+export * as WorkstreamSubgraph from "./workstream/index.js";
+export * as WorkstreamsSubgraph from "./workstreams/index.js";
+export * as NetworksSubgraph from "./networks/index.js";

package/dist/subgraphs/networks/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseSubgraph } from "@powerhousedao/reactor-api";
+import type { DocumentNode } from "graphql";
+export declare class NetworksSubgraph extends BaseSubgraph {
+    name: string;
+    typeDefs: DocumentNode;
+    resolvers: Record<string, unknown>;
+    additionalContextFields: {};
+    onSetup(): Promise<void>;
+    onDisconnect(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/subgraphs/networks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../subgraphs/networks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,IAAI,SAAc;IAClB,QAAQ,EAAE,YAAY,CAAU;IAChC,SAAS,0BAAsB;IAC/B,uBAAuB,KAAM;IACvB,OAAO;IACP,YAAY;CACnB"}

package/dist/subgraphs/networks/index.js

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

package/dist/subgraphs/networks/resolvers.d.ts

@@ -0,0 +1,3 @@
+import { type ISubgraph } from "@powerhousedao/reactor-api";
+export declare const getResolvers: (subgraph: ISubgraph) => Record<string, unknown>;
+//# sourceMappingURL=resolvers.d.ts.map

package/dist/subgraphs/networks/resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/networks/resolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,eAAO,MAAM,YAAY,GAAI,UAAU,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAoDxE,CAAC"}

package/dist/subgraphs/networks/resolvers.js

@@ -0,0 +1,42 @@
+import {} from "@powerhousedao/reactor-api";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    return {
+        Query: {
+            allNetworks: async () => {
+                const drives = await reactor.getDrives();
+                const docs = [];
+                for (const driveId of drives) {
+                    const docsIds = await reactor.getDocuments(driveId);
+                    const driveDocs = await Promise.allSettled(docsIds.map(async (docId) => reactor.getDocument(docId)));
+                    driveDocs.forEach((result) => {
+                        if (result.status === "fulfilled" &&
+                            result.value.header.documentType === "powerhouse/network-profile") {
+                            docs.push(result.value);
+                        }
+                    });
+                }
+                return docs.map((doc) => {
+                    const state = doc.state.global;
+                    return {
+                        id: doc.header.id,
+                        documentType: doc.header.documentType,
+                        network: {
+                            name: state.name,
+                            icon: state.icon,
+                            logo: state.logo,
+                            logoBig: state.logoBig,
+                            website: state.website ?? null,
+                            description: state.description,
+                            category: state.category,
+                            x: state.x ?? null,
+                            github: state.github ?? null,
+                            discord: state.discord ?? null,
+                            youtube: state.youtube ?? null,
+                        },
+                    };
+                });
+            },
+        },
+    };
+};

package/dist/subgraphs/networks/schema.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentNode } from "graphql";
+export declare const schema: DocumentNode;
+//# sourceMappingURL=schema.d.ts.map

package/dist/subgraphs/networks/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../subgraphs/networks/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,MAAM,EAAE,YAqCpB,CAAC"}

package/dist/subgraphs/networks/schema.js

@@ -0,0 +1,39 @@
+import { gql } from "graphql-tag";
+export const schema = gql `
+  """
+  Subgraph definition
+  """
+  type Query {
+    allNetworks: [AllNetworks!]!
+  }
+
+
+  type AllNetworks {
+    id: PHID
+    documentType: String
+    network: Network
+  }
+
+  type Network {
+    name: String!
+    icon: String!
+    logo: String!
+    logoBig: String!
+    website: String
+    description: String!
+    category: [NetworkCategory!]!
+    x: String
+    github: String
+    discord: String
+    youtube: String
+  }
+
+  enum NetworkCategory {
+    DEFI
+    OSS
+    CRYPTO
+    NGO
+    CHARITY
+  }
+
+`;

package/dist/subgraphs/payment-terms/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseSubgraph } from "@powerhousedao/reactor-api";
+import type { DocumentNode } from "graphql";
+export declare class PaymentTermsSubgraph extends BaseSubgraph {
+    name: string;
+    typeDefs: DocumentNode;
+    resolvers: Record<string, unknown>;
+    additionalContextFields: {};
+    onSetup(): Promise<void>;
+    onDisconnect(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/subgraphs/payment-terms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../subgraphs/payment-terms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,IAAI,SAAmB;IACvB,QAAQ,EAAE,YAAY,CAAU;IAChC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAsB;IACxD,uBAAuB,KAAM;IACvB,OAAO;IACP,YAAY;CACnB"}

package/dist/subgraphs/payment-terms/index.js

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

package/dist/subgraphs/payment-terms/resolvers.d.ts

@@ -0,0 +1,3 @@
+import { type ISubgraph } from "@powerhousedao/reactor-api";
+export declare const getResolvers: (subgraph: ISubgraph) => Record<string, unknown>;
+//# sourceMappingURL=resolvers.d.ts.map

package/dist/subgraphs/payment-terms/resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/payment-terms/resolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAwB5D,eAAO,MAAM,YAAY,GAAI,UAAU,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAqexE,CAAC"}