@powerhousedao/network-admin 1.0.0-dev.3 → 1.0.0-staging.4

package/dist/subgraphs/{payment-terms → builders-addon}/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseSubgraph } from "@powerhousedao/reactor-api";
 import type { DocumentNode } from "graphql";
-export declare class PaymentTermsSubgraph extends BaseSubgraph {
+export declare class BuildersAddonSubgraph extends BaseSubgraph {
     name: string;
     typeDefs: DocumentNode;
     resolvers: Record<string, unknown>;

package/dist/subgraphs/builders-addon/index.d.ts.map

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

package/dist/subgraphs/{workstream → builders-addon}/index.js

@@ -1,8 +1,8 @@
 import { BaseSubgraph } from "@powerhousedao/reactor-api";
 import { schema } from "./schema.js";
 import { getResolvers } from "./resolvers.js";
-export class WorkstreamSubgraph extends BaseSubgraph {
-    name = "workstream";
+export class BuildersAddonSubgraph extends BaseSubgraph {
+    name = "builders-addon";
     typeDefs = schema;
     resolvers = getResolvers(this);
     additionalContextFields = {};

package/dist/subgraphs/builders-addon/resolvers.d.ts.map

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

package/dist/subgraphs/builders-addon/resolvers.js

@@ -0,0 +1,442 @@
+import {} from "@powerhousedao/reactor-api";
+export const getResolvers = (subgraph) => {
+    const reactor = subgraph.reactor;
+    const extractPhid = (value) => {
+        if (typeof value === "string") {
+            return value.trim() || null;
+        }
+        if (value &&
+            typeof value === "object" &&
+            "id" in value &&
+            typeof value.id === "string") {
+            const id = value.id;
+            return id.trim() || null;
+        }
+        return null;
+    };
+    const getCandidateDrives = async () => {
+        try {
+            const drives = await reactor.getDrives?.();
+            if (Array.isArray(drives) && drives.length > 0)
+                return drives;
+        }
+        catch { }
+        return [];
+    };
+    const applyFilters = (builder, filter) => {
+        if (!filter)
+            return true;
+        if (filter.id && builder.id !== filter.id)
+            return false;
+        if (filter.code &&
+            String(builder.code || "").toLowerCase() !==
+                String(filter.code || "").toLowerCase())
+            return false;
+        if (filter.name &&
+            !String(builder.name || "").toLowerCase().includes(String(filter.name || "").toLowerCase()))
+            return false;
+        if (filter.slug &&
+            String(builder.slug || "").toLowerCase() !==
+                String(filter.slug || "").toLowerCase())
+            return false;
+        if (filter.status &&
+            String(builder.status || "").toLowerCase() !==
+                String(filter.status || "").toLowerCase())
+            return false;
+        if (filter.skills && filter.skills.length > 0) {
+            const builderSkills = (builder.skills || []).map((s) => String(s).toLowerCase());
+            const hasAllSkills = filter.skills.every((skill) => builderSkills.includes(String(skill).toLowerCase()));
+            if (!hasAllSkills)
+                return false;
+        }
+        if (filter.scopes && filter.scopes.length > 0) {
+            const builderScopes = (builder.scopes || []).map((s) => String(s).toLowerCase());
+            const hasAllScopes = filter.scopes.every((scope) => builderScopes.includes(String(scope).toLowerCase()));
+            if (!hasAllScopes)
+                return false;
+        }
+        if (filter.isOperator !== undefined && filter.isOperator !== null) {
+            if (builder.isOperator !== filter.isOperator)
+                return false;
+        }
+        return true;
+    };
+    return {
+        Query: {
+            builders: async (parent, args) => {
+                const drives = await getCandidateDrives();
+                const filter = args.filter;
+                let builderDocs = [];
+                const sowDocs = [];
+                const resourceTemplateDocs = [];
+                const allowedDriveIds = new Set(drives);
+                // Step 1: If networkSlug is provided, identify the network drive and valid builder PHIDs
+                if (filter?.networkSlug) {
+                    allowedDriveIds.clear();
+                    const targetNetworkSlug = filter.networkSlug.toLowerCase().trim();
+                    let targetDriveId = null;
+                    let builderPhids = [];
+                    // Find the network drive matching the slug
+                    for (const driveId of drives) {
+                        try {
+                            const docIds = await reactor.getDocuments(driveId);
+                            const docs = await Promise.all(docIds.map(async (docId) => {
+                                try {
+                                    return await reactor.getDocument(docId);
+                                }
+                                catch {
+                                    return null;
+                                }
+                            }));
+                            const networkDoc = docs.find((doc) => {
+                                if (!doc ||
+                                    doc.header.documentType !== "powerhouse/network-profile")
+                                    return false;
+                                const state = doc.state.global;
+                                if (!state?.name)
+                                    return false;
+                                const slug = state.name
+                                    .toLowerCase()
+                                    .trim()
+                                    .split(/\s+/)
+                                    .join("-");
+                                return slug === targetNetworkSlug;
+                            });
+                            if (networkDoc) {
+                                targetDriveId = driveId;
+                                // Get the builders list from this drive
+                                const buildersDoc = docs.find((doc) => doc && doc.header.documentType === "powerhouse/builders");
+                                if (buildersDoc) {
+                                    const state = buildersDoc.state.global;
+                                    if (Array.isArray(state.builders)) {
+                                        builderPhids = state.builders.filter((id) => typeof id === "string");
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        catch (error) {
+                            console.warn(`Failed to inspect drive ${driveId}:`, error);
+                        }
+                    }
+                    if (targetDriveId) {
+                        allowedDriveIds.add(targetDriveId);
+                        // Fetch SOWs from the network drive
+                        try {
+                            const docIds = await reactor.getDocuments(targetDriveId);
+                            for (const docId of docIds) {
+                                try {
+                                    const doc = await reactor.getDocument(docId);
+                                    if (doc.header.documentType === "powerhouse/scopeofwork") {
+                                        sowDocs.push(doc);
+                                    }
+                                    else if (doc.header.documentType === "powerhouse/resource-template") {
+                                        resourceTemplateDocs.push(doc);
+                                    }
+                                }
+                                catch { }
+                            }
+                        }
+                        catch (e) {
+                            console.warn(`Failed to fetch SOWs from drive ${targetDriveId}`, e);
+                        }
+                        // Fetch specific builder profiles
+                        builderDocs = (await Promise.all(builderPhids.map(async (phid) => {
+                            try {
+                                const doc = await reactor.getDocument(phid);
+                                return doc.header.documentType ===
+                                    "powerhouse/builder-profile"
+                                    ? doc
+                                    : null;
+                            }
+                            catch {
+                                return null;
+                            }
+                        }))).filter((doc) => doc !== null);
+                    }
+                }
+                else {
+                    // Default behavior: Scan all drives
+                    for (const driveId of drives) {
+                        try {
+                            const docIds = await reactor.getDocuments(driveId);
+                            const docs = await Promise.all(docIds.map(async (docId) => {
+                                try {
+                                    return await reactor.getDocument(docId);
+                                }
+                                catch {
+                                    return null;
+                                }
+                            }));
+                            for (const doc of docs) {
+                                if (!doc)
+                                    continue;
+                                if (doc.header.documentType === "powerhouse/builder-profile") {
+                                    builderDocs.push(doc);
+                                }
+                                else if (doc.header.documentType === "powerhouse/scopeofwork") {
+                                    sowDocs.push(doc);
+                                }
+                                else if (doc.header.documentType === "powerhouse/resource-template") {
+                                    resourceTemplateDocs.push(doc);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.warn(`Failed to process drive ${driveId}:`, error);
+                        }
+                    }
+                }
+                // Step 2: Build a map of deliverable OID -> deliverable object for each SOW
+                const sowDeliverablesMap = new Map();
+                for (const sowDoc of sowDocs) {
+                    const sowState = sowDoc.state.global;
+                    if (!sowState || typeof sowState !== "object")
+                        continue;
+                    const deliverablesMap = new Map();
+                    const deliverables = Array.isArray(sowState.deliverables)
+                        ? sowState.deliverables
+                        : [];
+                    for (const deliverable of deliverables) {
+                        if (!deliverable || typeof deliverable !== "object")
+                            continue;
+                        const deliverableId = deliverable.id;
+                        if (deliverableId && typeof deliverableId === "string") {
+                            deliverablesMap.set(deliverableId, deliverable);
+                        }
+                    }
+                    sowDeliverablesMap.set(sowDoc.header.id, deliverablesMap);
+                }
+                // Step 3: Extract projects from SOW documents and group by projectOwner
+                const projectsByOwner = new Map();
+                for (const sowDoc of sowDocs) {
+                    const sowState = sowDoc.state.global;
+                    if (!sowState || typeof sowState !== "object")
+                        continue;
+                    if (!Array.isArray(sowState.projects))
+                        continue;
+                    const deliverablesMap = sowDeliverablesMap.get(sowDoc.header.id) || new Map();
+                    for (const project of sowState.projects) {
+                        if (!project || typeof project !== "object")
+                            continue;
+                        const ownerPhid = extractPhid(project.projectOwner);
+                        if (!ownerPhid)
+                            continue;
+                        // Resolve scope deliverables from OIDs to actual deliverable objects
+                        let resolvedScope = null;
+                        if (project.scope && typeof project.scope === "object") {
+                            try {
+                                const scopeDeliverableOids = Array.isArray(project.scope.deliverables)
+                                    ? project.scope.deliverables
+                                    : [];
+                                const resolvedDeliverables = scopeDeliverableOids
+                                    .map((oid) => {
+                                    if (!oid || typeof oid !== "string")
+                                        return null;
+                                    const deliverable = deliverablesMap.get(oid);
+                                    if (!deliverable || typeof deliverable !== "object")
+                                        return null;
+                                    // Transform to SOW_Deliverable format with error handling
+                                    try {
+                                        return {
+                                            id: deliverable.id || "",
+                                            icon: deliverable.icon ?? null,
+                                            title: String(deliverable.title || ""),
+                                            code: String(deliverable.code || ""),
+                                            description: String(deliverable.description || ""),
+                                            status: deliverable.status || "DRAFT",
+                                            workProgress: deliverable.workProgress ?? null,
+                                            keyResults: Array.isArray(deliverable.keyResults)
+                                                ? deliverable.keyResults.map((kr) => ({
+                                                    id: kr?.id || "",
+                                                    title: String(kr?.title || ""),
+                                                    link: String(kr?.link || ""),
+                                                }))
+                                                : [],
+                                            budgetAnchor: deliverable.budgetAnchor ?? null,
+                                        };
+                                    }
+                                    catch (error) {
+                                        console.warn(`Failed to transform deliverable ${oid}:`, error);
+                                        return null;
+                                    }
+                                })
+                                    .filter((d) => d !== null);
+                                // Build resolved scope with error handling
+                                resolvedScope = {
+                                    deliverables: resolvedDeliverables,
+                                    status: project.scope.status ||
+                                        project.scope.deliverableSetStatus ||
+                                        "DRAFT",
+                                    progress: project.scope.progress ?? null,
+                                    deliverablesCompleted: project.scope
+                                        .deliverablesCompleted ?? {
+                                        total: 0,
+                                        completed: 0,
+                                    },
+                                };
+                            }
+                            catch (error) {
+                                console.warn(`Failed to resolve scope for project ${project.id}:`, error);
+                                // Fallback to empty scope
+                                resolvedScope = {
+                                    deliverables: [],
+                                    status: "DRAFT",
+                                    progress: null,
+                                    deliverablesCompleted: { total: 0, completed: 0 },
+                                };
+                            }
+                        }
+                        // Transform project to BuilderProject format with error handling
+                        try {
+                            const builderProject = {
+                                id: project.id || "",
+                                code: String(project.code || ""),
+                                title: String(project.title || ""),
+                                slug: String(project.slug || ""),
+                                abstract: project.abstract ?? null,
+                                imageUrl: project.imageUrl ?? null,
+                                scope: resolvedScope,
+                                budgetType: project.budgetType ?? null,
+                                currency: project.currency ?? null,
+                                budget: project.budget ?? null,
+                                expenditure: project.expenditure ?? null,
+                            };
+                            if (!projectsByOwner.has(ownerPhid)) {
+                                projectsByOwner.set(ownerPhid, []);
+                            }
+                            projectsByOwner.get(ownerPhid).push(builderProject);
+                        }
+                        catch (error) {
+                            console.warn(`Failed to transform project ${project.id}:`, error);
+                            // Skip this project if transformation fails
+                            continue;
+                        }
+                    }
+                }
+                // Step 3b: Extract products from resource-template documents and group by operatorId
+                const productsByOperator = new Map();
+                for (const rtDoc of resourceTemplateDocs) {
+                    const rtState = rtDoc.state.global;
+                    if (!rtState || typeof rtState !== "object")
+                        continue;
+                    const operatorId = rtState.operatorId;
+                    if (!operatorId || typeof operatorId !== "string")
+                        continue;
+                    try {
+                        const product = {
+                            id: rtState.id || rtDoc.header.id,
+                            operatorId,
+                            title: String(rtState.title || ""),
+                            summary: String(rtState.summary || ""),
+                            description: rtState.description ?? null,
+                            thumbnailUrl: rtState.thumbnailUrl ?? null,
+                            infoLink: rtState.infoLink ?? null,
+                            status: rtState.status || "DRAFT",
+                            lastModified: rtState.lastModified ?? null,
+                            targetAudiences: Array.isArray(rtState.targetAudiences)
+                                ? rtState.targetAudiences
+                                : [],
+                            setupServices: Array.isArray(rtState.setupServices)
+                                ? rtState.setupServices
+                                : [],
+                            recurringServices: Array.isArray(rtState.recurringServices)
+                                ? rtState.recurringServices
+                                : [],
+                            facetTargets: Array.isArray(rtState.facetTargets)
+                                ? rtState.facetTargets
+                                : [],
+                            services: Array.isArray(rtState.services)
+                                ? rtState.services
+                                : [],
+                            optionGroups: Array.isArray(rtState.optionGroups)
+                                ? rtState.optionGroups
+                                : [],
+                            faqFields: Array.isArray(rtState.faqFields)
+                                ? rtState.faqFields
+                                : [],
+                            contentSections: Array.isArray(rtState.contentSections)
+                                ? rtState.contentSections
+                                : [],
+                        };
+                        if (!productsByOperator.has(operatorId)) {
+                            productsByOperator.set(operatorId, []);
+                        }
+                        productsByOperator.get(operatorId).push(product);
+                    }
+                    catch (error) {
+                        console.warn(`Failed to transform resource-template ${rtDoc.header.id}:`, error);
+                    }
+                }
+                // Step 4: Transform builder documents to BuilderProfileState format
+                const builders = builderDocs
+                    .map((doc) => {
+                    const state = doc.state.global;
+                    // Ensure all non-nullable fields are properly handled
+                    const name = String(state?.name ?? doc.header?.name ?? "");
+                    const icon = String(state?.icon ?? "");
+                    const description = String(state?.description ?? state?.slug ?? "");
+                    const about = String(state?.about ?? "");
+                    const isOperator = state?.isOperator ?? false;
+                    const operationalHubMember = state?.operationalHubMember ?? { name: null, phid: null };
+                    // Document model uses 'skils' (typo), but GraphQL schema uses 'skills'
+                    const skills = Array.isArray(state?.skils)
+                        ? state.skils
+                        : Array.isArray(state?.skills)
+                            ? state.skills
+                            : [];
+                    const scopes = Array.isArray(state?.scopes) ? state.scopes : [];
+                    const links = Array.isArray(state?.links) ? state.links : [];
+                    const contributors = Array.isArray(state?.contributors)
+                        ? state.contributors
+                        : [];
+                    const builder = {
+                        id: doc.header.id,
+                        code: state?.code ?? null,
+                        slug: state?.slug ?? null,
+                        name,
+                        icon,
+                        description,
+                        about,
+                        lastModified: state?.lastModified ?? null,
+                        isOperator,
+                        operationalHubMember,
+                        contributors,
+                        status: state?.status ?? null,
+                        skills,
+                        scopes,
+                        links,
+                        projects: projectsByOwner.get(doc.header.id) || [],
+                        products: productsByOperator.get(doc.header.id) || [],
+                    };
+                    return builder;
+                })
+                    .filter((builder) => {
+                    // Apply standard filters
+                    if (!applyFilters(builder, filter)) {
+                        return false;
+                    }
+                    return true;
+                });
+                return builders;
+            },
+        },
+        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/builders-addon/schema.d.ts.map

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