@powerhousedao/network-admin 0.0.28 → 0.0.30

package/dist/subgraphs/workstreams/resolvers.js

@@ -0,0 +1,377 @@
+import { WorkstreamsProcessor } from "../../processors/workstreams/index.js";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    const db = subgraph.relationalDb;
+    const deriveSlug = (name) => name.toLowerCase().trim().split(/\s+/).join("-");
+    const getCandidateDrives = async () => {
+        try {
+            const drives = await reactor.getDrives?.();
+            if (Array.isArray(drives) && drives.length > 0)
+                return drives;
+        }
+        catch { }
+        return [];
+    };
+    const loadLinkedDocument = async (id) => {
+        if (!id)
+            return null;
+        try {
+            const linked = await reactor.getDocument(id);
+            return { id, stateJSON: linked.state.global };
+        }
+        catch {
+            return { id, stateJSON: null };
+        }
+    };
+    const loadRfpDetails = async (rfpRef) => {
+        if (!rfpRef?.id) {
+            return null;
+        }
+        try {
+            const rfpDoc = await reactor.getDocument(rfpRef.id);
+            const rfpState = rfpDoc.state.global;
+            return {
+                id: rfpRef.id,
+                code: rfpState?.code ?? null,
+                title: rfpRef.title ?? rfpState?.title ?? null,
+                status: rfpState?.status ?? null,
+                summary: rfpState?.summary ?? null,
+                submissionDeadline: rfpState?.deadline ?? null,
+                budgetMin: rfpState?.budgetRange?.min ?? null,
+                budgetMax: rfpState?.budgetRange?.max ?? null,
+                budgetCurrency: rfpState?.budgetRange?.currency ?? null,
+                eligibilityCriteria: rfpState?.eligibilityCriteria ?? null,
+                evaluationCriteria: rfpState?.evaluationCriteria ?? null,
+                briefing: rfpState?.briefing ?? null,
+            };
+        }
+        catch {
+            return {
+                id: rfpRef.id,
+                code: null,
+                title: rfpRef.title ?? null,
+                status: null,
+                summary: null,
+                submissionDeadline: null,
+                budgetMin: null,
+                budgetMax: null,
+                budgetCurrency: null,
+                eligibilityCriteria: null,
+                evaluationCriteria: null,
+                briefing: null,
+            };
+        }
+    };
+    const hydrateWorkstreamRow = async (row) => {
+        try {
+            const doc = await reactor.getDocument(row.workstream_phid);
+            const state = doc.state.global;
+            const initialProposalBase = state.initialProposal
+                ? {
+                    id: state.initialProposal.id,
+                    status: state.initialProposal.status,
+                    author: state.initialProposal.author,
+                }
+                : null;
+            const alternativeProposalsBase = (state.alternativeProposals || []).map((p) => ({
+                id: p.id,
+                status: p.status,
+                author: p.author,
+            }));
+            const [topSowDoc, topPaymentTermsDoc, initialSowDoc, initialPaymentTermsDoc, altSowDocs, altPaymentDocs, rfpDetails,] = await Promise.all([
+                loadLinkedDocument(state.sow || row.sow_phid || null),
+                loadLinkedDocument(state.paymentTerms || null),
+                loadLinkedDocument(state.initialProposal?.sow || row.sow_phid || null),
+                loadLinkedDocument(state.initialProposal?.paymentTerms || null),
+                Promise.all((state.alternativeProposals || []).map((p) => loadLinkedDocument(p.sow || null))),
+                Promise.all((state.alternativeProposals || []).map((p) => loadLinkedDocument(p.paymentTerms || null))),
+                loadRfpDetails(state.rfp || null),
+            ]);
+            const client = state.client ??
+                (row.network_phid
+                    ? { id: row.network_phid, name: row.network_slug, icon: null }
+                    : null);
+            return {
+                code: state.code || null,
+                title: state.title || row.workstream_title || null,
+                status: state.status || row.workstream_status || null,
+                client,
+                rfp: rfpDetails,
+                initialProposal: initialProposalBase
+                    ? {
+                        ...initialProposalBase,
+                        sow: initialSowDoc?.stateJSON || null,
+                        paymentTerms: initialPaymentTermsDoc?.stateJSON || null,
+                    }
+                    : null,
+                alternativeProposals: alternativeProposalsBase.map((proposal, index) => ({
+                    ...proposal,
+                    sow: altSowDocs[index]?.stateJSON || null,
+                    paymentTerms: altPaymentDocs[index]?.stateJSON || null,
+                })),
+                sow: topSowDoc?.stateJSON || null,
+                paymentTerms: topPaymentTermsDoc?.stateJSON || null,
+                paymentRequests: state.paymentRequests || [],
+            };
+        }
+        catch {
+            return {
+                code: row.workstream_title || null,
+                title: row.workstream_title || null,
+                status: row.workstream_status || null,
+                client: row.network_phid
+                    ? { id: row.network_phid, name: row.network_slug, icon: null }
+                    : null,
+                rfp: null,
+                initialProposal: null,
+                alternativeProposals: [],
+                sow: null,
+                paymentTerms: null,
+                paymentRequests: [],
+            };
+        }
+    };
+    const applyWorkstreamFilters = (qb, filters, wantedSlug) => {
+        if (filters.workstreamId) {
+            qb = qb.where("workstream_phid", "=", filters.workstreamId);
+        }
+        else if (filters.workstreamSlug) {
+            qb = qb.where("workstream_slug", "=", filters.workstreamSlug);
+        }
+        if (filters.networkId) {
+            qb = qb.where("network_phid", "=", filters.networkId);
+        }
+        else if (filters.networkSlug) {
+            qb = qb.where("network_slug", "=", filters.networkSlug);
+        }
+        else if (filters.networkName && wantedSlug) {
+            qb = qb.where("network_slug", "=", wantedSlug);
+        }
+        const statuses = (filters.workstreamStatuses || []).filter((status) => Boolean(status));
+        if (statuses.length > 0) {
+            qb = qb.where("workstream_status", "in", statuses);
+        }
+        else if (filters.workstreamStatus) {
+            qb = qb.where("workstream_status", "=", filters.workstreamStatus);
+        }
+        return qb;
+    };
+    const applyScopeOfWorkFilters = (qb, filters, wantedSlug) => {
+        if (filters.workstreamId) {
+            qb = qb.where("workstream_phid", "=", filters.workstreamId);
+        }
+        else if (filters.workstreamSlug) {
+            qb = qb.where("workstream_slug", "=", filters.workstreamSlug);
+        }
+        if (filters.networkId) {
+            qb = qb.where("network_phid", "=", filters.networkId);
+        }
+        else if (filters.networkSlug) {
+            qb = qb.where("network_slug", "=", filters.networkSlug);
+        }
+        else if (filters.networkName && wantedSlug) {
+            qb = qb.where("network_slug", "=", wantedSlug);
+        }
+        if (filters.workstreamStatus) {
+            qb = qb.where("workstream_status", "=", filters.workstreamStatus);
+        }
+        return qb;
+    };
+    return {
+        Query: {
+            processorWorkstreams: async (parent, args) => {
+                const drives = await getCandidateDrives();
+                const allProcessorWorkstreams = await Promise.all(drives.map(async (driveId) => {
+                    return WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll()
+                        .execute();
+                }));
+                // Flatten the array of arrays into a single array
+                const flattenedWorkstreams = allProcessorWorkstreams.flat();
+                return flattenedWorkstreams.map((workstream) => ({
+                    network_phid: workstream.network_phid,
+                    network_slug: workstream.network_slug,
+                    workstream_phid: workstream.workstream_phid,
+                    workstream_slug: workstream.workstream_slug,
+                    workstream_title: workstream.workstream_title,
+                    workstream_status: workstream.workstream_status,
+                    sow_phid: workstream.sow_phid,
+                    roadmap_oid: workstream.roadmap_oid,
+                    final_milestone_target: workstream.final_milestone_target,
+                    initial_proposal_status: workstream.initial_proposal_status,
+                    initial_proposal_author: workstream.initial_proposal_author,
+                }));
+            },
+            workstream: async (parent, args) => {
+                const filters = args.filter || {};
+                const candidateDrives = await getCandidateDrives();
+                const wantedSlug = filters.networkSlug ||
+                    (filters.networkName ? deriveSlug(filters.networkName) : undefined);
+                let resolved = null;
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyWorkstreamFilters(qb, filters, wantedSlug);
+                    const row = await qb.executeTakeFirst();
+                    if (!row)
+                        continue;
+                    resolved = await hydrateWorkstreamRow(row);
+                    break;
+                }
+                return resolved;
+            },
+            workstreams: async (parent, args) => {
+                const filters = args.filter || {};
+                const candidateDrives = await getCandidateDrives();
+                // Check if any filters are provided
+                const hasFilters = filters.networkId ||
+                    filters.networkSlug ||
+                    filters.networkName ||
+                    filters.workstreamStatus ||
+                    (filters.workstreamStatuses &&
+                        filters.workstreamStatuses.length > 0);
+                const wantedSlug = filters.networkSlug ||
+                    (filters.networkName ? deriveSlug(filters.networkName) : undefined);
+                const results = [];
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    // Only apply filters if any are provided
+                    if (hasFilters) {
+                        const filterArgs = {
+                            networkId: filters.networkId,
+                            networkSlug: filters.networkSlug,
+                            networkName: filters.networkName,
+                            workstreamStatus: filters.workstreamStatus,
+                            workstreamStatuses: filters.workstreamStatuses,
+                        };
+                        qb = applyWorkstreamFilters(qb, filterArgs, wantedSlug);
+                    }
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        results.push(hydrated);
+                    }
+                }
+                return results;
+            },
+            rfpByWorkstream: async (parent, args) => {
+                const filters = args.filter || {};
+                const candidateDrives = await getCandidateDrives();
+                const wantedSlug = filters.networkSlug ||
+                    (filters.networkName ? deriveSlug(filters.networkName) : undefined);
+                const results = [];
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyWorkstreamFilters(qb, filters, wantedSlug);
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        results.push({
+                            code: hydrated.code,
+                            title: hydrated.title,
+                            status: hydrated.status,
+                            rfp: hydrated.rfp,
+                        });
+                    }
+                    if (filters.workstreamId || filters.workstreamSlug) {
+                        break;
+                    }
+                }
+                return results;
+            },
+            scopeOfWorkByNetworkOrStatus: async (parent, args) => {
+                const filters = args.filter || {};
+                const candidateDrives = await getCandidateDrives();
+                const wantedSlug = filters.networkSlug ||
+                    (filters.networkName ? deriveSlug(filters.networkName) : undefined);
+                const results = [];
+                for (const driveId of candidateDrives) {
+                    let qb = WorkstreamsProcessor.query(driveId, db)
+                        .selectFrom("workstreams")
+                        .selectAll();
+                    qb = applyScopeOfWorkFilters(qb, filters, wantedSlug);
+                    const rows = await qb.execute();
+                    if (rows.length === 0) {
+                        continue;
+                    }
+                    for (const row of rows) {
+                        const hydrated = await hydrateWorkstreamRow(row);
+                        // Collect SOWs based on proposalRole filter
+                        const sowDocs = [];
+                        if (!filters.proposalRole) {
+                            // If no proposalRole specified, include all SOWs
+                            if (hydrated.sow) {
+                                sowDocs.push(hydrated.sow);
+                            }
+                            if (hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
+                            }
+                            for (const altProposal of hydrated.alternativeProposals || []) {
+                                if (altProposal.sow) {
+                                    sowDocs.push(altProposal.sow);
+                                }
+                            }
+                        }
+                        else if (filters.proposalRole === "INITIAL") {
+                            if (hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
+                            }
+                        }
+                        else if (filters.proposalRole === "ALTERNATIVE") {
+                            for (const altProposal of hydrated.alternativeProposals || []) {
+                                if (altProposal.sow) {
+                                    sowDocs.push(altProposal.sow);
+                                }
+                            }
+                        }
+                        else if (filters.proposalRole === "AWARDED") {
+                            // For AWARDED, we check if the workstream status is AWARDED
+                            // and return the initial proposal's SOW (as it's typically the awarded one)
+                            if (hydrated.status === "AWARDED" && hydrated.initialProposal?.sow) {
+                                sowDocs.push(hydrated.initialProposal.sow);
+                            }
+                        }
+                        // Filter out null/undefined SOWs and add to results
+                        for (const sow of sowDocs) {
+                            if (sow) {
+                                results.push(sow);
+                            }
+                        }
+                    }
+                    if (filters.workstreamId || filters.workstreamSlug) {
+                        break;
+                    }
+                }
+                return results;
+            },
+        },
+        SOW_Progress: {
+            __resolveType(obj) {
+                if (obj && typeof obj === "object") {
+                    if (Object.prototype.hasOwnProperty.call(obj, "total") && Object.prototype.hasOwnProperty.call(obj, "completed")) {
+                        return "SOW_StoryPoint";
+                    }
+                    if (Object.prototype.hasOwnProperty.call(obj, "value")) {
+                        return "SOW_Percentage";
+                    }
+                    if (Object.prototype.hasOwnProperty.call(obj, "done")) {
+                        return "SOW_Binary";
+                    }
+                }
+                return null;
+            }
+        }
+    };
+};

package/dist/subgraphs/workstreams/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/workstreams/schema.d.ts.map

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