@powerhousedao/contributor-billing 1.0.0-dev.3 → 1.0.0-dev.5

package/dist/subgraphs/budget-statements/resolvers.js

@@ -1,38 +1,37 @@
 import {} from "@powerhousedao/reactor-api";
+// Helper to extract YYYY-MM-DD from an ISO date string without Date object
+// to avoid timezone-dependent parsing
+export const extractIsoDate = (dateStr) => {
+    const match = dateStr.match(/^(\d{4}-\d{2}-\d{2})/);
+    return match ? match[1] : null;
+};
 // Helper to create a period key from start and end dates
-const getPeriodKey = (periodStart, periodEnd) => {
+export const getPeriodKey = (periodStart, periodEnd) => {
     if (!periodStart || !periodEnd)
         return null;
-    // Normalize dates to YYYY-MM-DD format for consistent matching
-    const startDate = new Date(periodStart);
-    const endDate = new Date(periodEnd);
-    if (isNaN(startDate.getTime()) || isNaN(endDate.getTime()))
+    const start = extractIsoDate(periodStart);
+    const end = extractIsoDate(periodEnd);
+    if (!start || !end)
         return null;
-    const formatDate = (d) => d.toISOString().split("T")[0];
-    return `${formatDate(startDate)}_${formatDate(endDate)}`;
+    return `${start}_${end}`;
 };
-// Helper to extract month key from date (format: "JAN2026")
-const getMonthKey = (dateStr) => {
+const MONTHS = [
+    "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
+    "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
+];
+// Helper to extract month key from an ISO date string (format: "SEP2025")
+// Parses directly from the string to avoid timezone issues
+export const getMonthKey = (dateStr) => {
     if (!dateStr)
         return null;
-    const date = new Date(dateStr);
-    if (isNaN(date.getTime()))
+    const match = dateStr.match(/^(\d{4})-(\d{2})/);
+    if (!match)
+        return null;
+    const year = match[1];
+    const monthIndex = parseInt(match[2], 10) - 1;
+    if (monthIndex < 0 || monthIndex > 11)
         return null;
-    const months = [
-        "JAN",
-        "FEB",
-        "MAR",
-        "APR",
-        "MAY",
-        "JUN",
-        "JUL",
-        "AUG",
-        "SEP",
-        "OCT",
-        "NOV",
-        "DEC",
-    ];
-    return `${months[date.getMonth()]}${date.getFullYear()}`;
+    return `${MONTHS[monthIndex]}${year}`;
 };
 // Helper to sort budget statements by month (most recent first)
 const sortByMonth = (a, b) => {
@@ -162,9 +161,50 @@ export const getResolvers = (subgraph) => {
                         }
                     }
                 }
-                // Step 2: Group reports by ownerId AND period
+                // Step 2: Resolve builder profiles and build opHub lookup
+                // We need this before grouping so snapshot reports can be shared across op hub members
+                const resolvedProfiles = new Map();
+                const builderToOpHub = new Map();
+                const resolveProfile = async (phid) => {
+                    if (resolvedProfiles.has(phid))
+                        return resolvedProfiles.get(phid);
+                    let doc = builderProfileDocs.get(phid) || null;
+                    if (!doc) {
+                        try {
+                            doc = await reactor.getDocument(phid);
+                        }
+                        catch {
+                            // Profile may not exist
+                        }
+                    }
+                    const state = doc
+                        ? (doc.state
+                            ?.global ?? null)
+                        : null;
+                    resolvedProfiles.set(phid, state);
+                    if (state?.operationalHubMember?.phid) {
+                        builderToOpHub.set(phid, state.operationalHubMember.phid);
+                    }
+                    return state;
+                };
+                // Pre-resolve all builder profiles we'll need
+                const allOwnerIds = new Set();
+                for (const doc of snapshotReportDocs) {
+                    const id = doc.state.global.ownerIds?.[0];
+                    if (id)
+                        allOwnerIds.add(id);
+                }
+                for (const doc of expenseReportDocs) {
+                    const id = doc.state.global.ownerId;
+                    if (id)
+                        allOwnerIds.add(id);
+                }
+                await Promise.all(Array.from(allOwnerIds).map((id) => resolveProfile(id)));
+                // Step 3: Group reports by ownerId AND period
                 // Key format: "ownerId_periodStart_periodEnd"
                 const budgetStatementsByOwnerAndPeriod = new Map();
+                // Index snapshot reports by opHub + period so they can be shared
+                const snapshotByOpHub = new Map();
                 // Group snapshot reports
                 for (const snapshotDoc of snapshotReportDocs) {
                     const state = snapshotDoc.state.global;
@@ -185,6 +225,11 @@ export const getResolvers = (subgraph) => {
                     }
                     budgetStatementsByOwnerAndPeriod.get(key).snapshotReport =
                         snapshotDoc;
+                    // Also index by opHub + period for sharing across subteams
+                    const opHubPhid = builderToOpHub.get(ownerId);
+                    if (opHubPhid) {
+                        snapshotByOpHub.set(`${opHubPhid}_${periodKey}`, snapshotDoc);
+                    }
                 }
                 // Group expense reports and match with snapshot reports
                 for (const expenseDoc of expenseReportDocs) {
@@ -206,25 +251,22 @@ export const getResolvers = (subgraph) => {
                     }
                     budgetStatementsByOwnerAndPeriod.get(key).expenseReport = expenseDoc;
                 }
-                // Step 3: Build the budget statements
+                // Step 4: Fill in missing snapshot reports from op hub siblings
+                for (const entry of budgetStatementsByOwnerAndPeriod.values()) {
+                    if (entry.snapshotReport)
+                        continue; // already has a direct match
+                    const opHubPhid = builderToOpHub.get(entry.ownerId);
+                    if (!opHubPhid)
+                        continue;
+                    const opHubSnapshot = snapshotByOpHub.get(`${opHubPhid}_${entry.periodKey}`);
+                    if (opHubSnapshot) {
+                        entry.snapshotReport = opHubSnapshot;
+                    }
+                }
+                // Step 5: Build the budget statements
                 const budgetStatements = [];
                 for (const [key, { ownerId, periodKey, snapshotReport, expenseReport },] of budgetStatementsByOwnerAndPeriod.entries()) {
-                    // Get the builder profile for this owner
-                    let builderProfileDoc = builderProfileDocs.get(ownerId) || null;
-                    // Try to fetch directly if not found
-                    if (!builderProfileDoc) {
-                        try {
-                            builderProfileDoc =
-                                await reactor.getDocument(ownerId);
-                        }
-                        catch {
-                            // Ignore errors - profile may not exist
-                        }
-                    }
-                    // Build owner object
-                    const ownerState = builderProfileDoc
-                        ? (builderProfileDoc.state?.global ?? null)
-                        : null;
+                    const ownerState = resolvedProfiles.get(ownerId) ?? null;
                     const owner = {
                         id: ownerId,
                         name: ownerState?.name || "Unknown",
@@ -257,16 +299,45 @@ export const getResolvers = (subgraph) => {
                     const status = expenseReport?.state.global.status || "DRAFT";
                     // Get lastModifiedAtUtcIso from the expense report document header
                     const lastModifiedAtUtcIso = expenseReport?.header.lastModifiedAtUtcIso || "";
+                    // Get operational hub member from builder profile
+                    const opHubMember = ownerState?.operationalHubMember ?? null;
+                    const operationalHubMember = opHubMember?.phid || opHubMember?.name
+                        ? { phid: opHubMember.phid || null, name: opHubMember.name || null }
+                        : null;
                     budgetStatements.push({
                         id: key,
                         owner,
+                        operationalHubMember,
                         month,
                         status,
                         lastModifiedAtUtcIso,
+                        reportedActuals: computeReportedActuals(expenseReportData),
+                        netExpenseTxns: computeNetExpenseTxns(snapshotReportData),
                         snapshotReport: snapshotReportData,
                         expenseReport: expenseReportData,
                     });
                 }
+                // Aggregate reportedActuals by operational hub + month
+                // All builders in the same op hub for the same month share the same total
+                const opHubActuals = new Map();
+                for (const stmt of budgetStatements) {
+                    const opHubPhid = stmt.operationalHubMember?.phid;
+                    if (!opHubPhid)
+                        continue;
+                    const groupKey = `${opHubPhid}_${stmt.month}`;
+                    const current = opHubActuals.get(groupKey) || 0;
+                    opHubActuals.set(groupKey, current + (parseFloat(stmt.reportedActuals.value) || 0));
+                }
+                for (const stmt of budgetStatements) {
+                    const opHubPhid = stmt.operationalHubMember?.phid;
+                    if (!opHubPhid)
+                        continue;
+                    const groupKey = `${opHubPhid}_${stmt.month}`;
+                    const total = opHubActuals.get(groupKey);
+                    if (total !== undefined) {
+                        stmt.reportedActuals = { unit: "USDS", value: String(total) };
+                    }
+                }
                 // Sort by month (most recent first)
                 budgetStatements.sort(sortByMonth);
                 return budgetStatements;
@@ -404,3 +475,39 @@ function getCounterPartyName(counterPartyAccountId, accountTransactionsDocs) {
     }
     return "";
 }
+/**
+ * Sum of all line item actuals from expense report wallets
+ */
+export function computeReportedActuals(expenseReportData) {
+    let total = 0;
+    for (const wallet of expenseReportData.wallets) {
+        for (const item of wallet.lineItems) {
+            total += parseFloat(item.actuals.value) || 0;
+        }
+    }
+    return { unit: "USDS", value: String(total) };
+}
+// USD stablecoins to include in net expense calculation
+const USD_STABLECOINS = new Set(["USDS", "USDC", "DAI"]);
+/**
+ * Sum of outbound USD stablecoin transactions that leave the Internal wallet grouping.
+ * Excludes Swap (token conversion) and Internal (inter-wallet transfers) flowTypes.
+ * Only counts USDS, USDC, and DAI — excludes sUSDS, EURe, SKY, MKR, etc.
+ */
+export function computeNetExpenseTxns(snapshotReportData) {
+    let total = 0;
+    for (const account of snapshotReportData.accounts) {
+        if (account.type !== "Internal")
+            continue;
+        for (const tx of account.transactions) {
+            if (tx.direction !== "OUTFLOW")
+                continue;
+            if (tx.flowType === "Swap" || tx.flowType === "Internal")
+                continue;
+            if (!USD_STABLECOINS.has(tx.amount.unit))
+                continue;
+            total += parseFloat(tx.amount.value.value) || 0;
+        }
+    }
+    return { unit: "USDS", value: String(total) };
+}

package/dist/subgraphs/budget-statements/resolvers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resolvers.test.d.ts.map

package/dist/subgraphs/budget-statements/resolvers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.test.d.ts","sourceRoot":"","sources":["../../../subgraphs/budget-statements/resolvers.test.ts"],"names":[],"mappings":""}

package/dist/subgraphs/budget-statements/resolvers.test.js

@@ -0,0 +1,329 @@
+import { describe, it, expect } from "vitest";
+import { computeReportedActuals, computeNetExpenseTxns, extractIsoDate, getPeriodKey, getMonthKey, } from "./resolvers.js";
+const amt = (value) => ({
+    unit: "USDS",
+    value: String(value),
+});
+describe("computeReportedActuals", () => {
+    it("returns zero when there are no wallets", () => {
+        expect(computeReportedActuals({ wallets: [] })).toEqual(amt(0));
+    });
+    it("returns zero when wallets have no line items", () => {
+        expect(computeReportedActuals({
+            wallets: [{ lineItems: [] }, { lineItems: [] }],
+        })).toEqual(amt(0));
+    });
+    it("sums actuals from a single wallet", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: amt(100) },
+                        { actuals: amt(250.5) },
+                        { actuals: amt(49.5) },
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(400));
+    });
+    it("sums actuals across multiple wallets", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [{ actuals: amt(100) }, { actuals: amt(200) }],
+                },
+                {
+                    lineItems: [{ actuals: amt(300) }],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(600));
+    });
+    it("treats non-numeric values as zero", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: amt("abc") },
+                        { actuals: amt(100) },
+                        { actuals: amt("") },
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("handles negative actuals", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [{ actuals: amt(-50) }, { actuals: amt(200) }],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("sums actuals regardless of unit on line items (all currently USDS)", () => {
+        // In practice the expense report builder hardcodes unit="USDS",
+        // but if line items had different units, values are still summed as-is.
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: { unit: "USDS", value: "100" } },
+                        { actuals: { unit: "DAI", value: "200" } },
+                        { actuals: { unit: "ETH", value: "1.5" } },
+                    ],
+                },
+            ],
+        });
+        // 100 + 200 + 1.5 = 301.5 (no conversion, sums raw values)
+        expect(result).toEqual(amt(301.5));
+    });
+});
+describe("extractIsoDate", () => {
+    it("extracts YYYY-MM-DD from full ISO string", () => {
+        expect(extractIsoDate("2025-09-01T00:00:00.000Z")).toBe("2025-09-01");
+    });
+    it("extracts YYYY-MM-DD from date-only string", () => {
+        expect(extractIsoDate("2025-09-01")).toBe("2025-09-01");
+    });
+    it("returns null for invalid input", () => {
+        expect(extractIsoDate("not-a-date")).toBeNull();
+        expect(extractIsoDate("")).toBeNull();
+    });
+});
+describe("getPeriodKey", () => {
+    it("creates key from ISO date strings", () => {
+        expect(getPeriodKey("2025-09-01T00:00:00.000Z", "2025-09-30T23:59:59.999Z")).toBe("2025-09-01_2025-09-30");
+    });
+    it("returns null when either date is missing", () => {
+        expect(getPeriodKey(null, "2025-09-30T00:00:00.000Z")).toBeNull();
+        expect(getPeriodKey("2025-09-01T00:00:00.000Z", null)).toBeNull();
+        expect(getPeriodKey(null, null)).toBeNull();
+    });
+});
+describe("getMonthKey", () => {
+    it("extracts month key from UTC midnight ISO string", () => {
+        expect(getMonthKey("2025-09-01T00:00:00.000Z")).toBe("SEP2025");
+    });
+    it("is not affected by timezone — UTC midnight stays in correct month", () => {
+        // This was the original bug: new Date("2025-09-01T00:00:00.000Z").getMonth()
+        // returns 7 (August) in UTC-3 because it becomes Aug 31 21:00 local time
+        expect(getMonthKey("2025-09-01T00:00:00.000Z")).toBe("SEP2025");
+        expect(getMonthKey("2025-01-01T00:00:00.000Z")).toBe("JAN2025");
+        expect(getMonthKey("2025-12-01T00:00:00.000Z")).toBe("DEC2025");
+    });
+    it("handles all months", () => {
+        const expected = [
+            "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
+            "JUL", "AUG", "SEP", "OCT", "NOV", "DEC",
+        ];
+        for (let i = 0; i < 12; i++) {
+            const month = String(i + 1).padStart(2, "0");
+            expect(getMonthKey(`2026-${month}-15T12:00:00.000Z`)).toBe(`${expected[i]}2026`);
+        }
+    });
+    it("returns null for null or invalid input", () => {
+        expect(getMonthKey(null)).toBeNull();
+        expect(getMonthKey("not-a-date")).toBeNull();
+        expect(getMonthKey("")).toBeNull();
+    });
+});
+const makeTx = (direction, flowType, value, token = "USDS") => ({
+    direction,
+    flowType,
+    amount: { value: { unit: token, value: String(value) }, unit: token },
+});
+describe("computeNetExpenseTxns", () => {
+    it("returns zero when there are no accounts", () => {
+        expect(computeNetExpenseTxns({ accounts: [] })).toEqual(amt(0));
+    });
+    it("returns zero when there are no Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Source",
+                    transactions: [makeTx("OUTFLOW", "External", 500)],
+                },
+                {
+                    type: "Destination",
+                    transactions: [makeTx("OUTFLOW", "External", 300)],
+                },
+                {
+                    type: "External",
+                    transactions: [makeTx("OUTFLOW", "External", 200)],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("sums only OUTFLOW transactions from Internal accounts that leave the group", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100), // counted: leaves group
+                        makeTx("INFLOW", "TopUp", 500), // ignored: inflow
+                        makeTx("OUTFLOW", "Internal", 200), // ignored: stays within group
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("excludes Swap transactions", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100),
+                        makeTx("OUTFLOW", "Swap", 999), // excluded
+                        makeTx("OUTFLOW", "TopUp", 50),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("sums across multiple Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [makeTx("OUTFLOW", "External", 100)],
+                },
+                {
+                    type: "Internal",
+                    transactions: [makeTx("OUTFLOW", "Return", 200)],
+                },
+                {
+                    type: "Source",
+                    transactions: [makeTx("OUTFLOW", "External", 9999)], // ignored: not Internal
+                },
+            ],
+        });
+        expect(result).toEqual(amt(300));
+    });
+    it("excludes Internal flowType (inter-wallet transfers stay in group)", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "Internal", 500), // excluded: stays in group
+                        makeTx("OUTFLOW", "Internal", 300), // excluded: stays in group
+                        makeTx("OUTFLOW", "External", 100), // counted: leaves group
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("returns zero when all Internal txns are swaps, internal transfers, or inflows", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "Swap", 100), // excluded: swap
+                        makeTx("OUTFLOW", "Internal", 400), // excluded: stays in group
+                        makeTx("INFLOW", "External", 200), // excluded: inflow
+                        makeTx("INFLOW", "Swap", 300), // excluded: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("counts External, Return, and TopUp outflows as expenses leaving the group", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100), // counted: to external party
+                        makeTx("OUTFLOW", "Return", 200), // counted: returning to source
+                        makeTx("OUTFLOW", "TopUp", 50), // counted: funding destination
+                        makeTx("OUTFLOW", "Swap", 999), // excluded: token conversion
+                        makeTx("OUTFLOW", "Internal", 888), // excluded: inter-wallet
+                        makeTx("INFLOW", "TopUp", 5000), // excluded: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(350));
+    });
+    it("handles Internal accounts with no transactions", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [{ type: "Internal", transactions: [] }],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("treats non-numeric amounts as zero", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", "bad"),
+                        makeTx("OUTFLOW", "External", 100),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("only counts USD stablecoins (USDS, USDC, DAI)", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 500, "USDS"), // counted
+                        makeTx("OUTFLOW", "External", 200, "USDC"), // counted
+                        makeTx("OUTFLOW", "External", 100, "DAI"), // counted
+                        makeTx("OUTFLOW", "External", 1.5, "ETH"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 9999, "sUSDS"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 5000, "SKY"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 134, "MKR"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 46, "EURe"), // excluded: not stablecoin
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(800));
+    });
+    it("excludes Swap even for stablecoin tokens", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100, "USDS"),
+                        makeTx("OUTFLOW", "Swap", 2000, "USDC"), // excluded: swap
+                        makeTx("OUTFLOW", "External", 50, "DAI"),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("ignores INFLOW of any token on Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100, "USDS"),
+                        makeTx("INFLOW", "TopUp", 5000, "ETH"), // ignored: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+});

package/dist/subgraphs/budget-statements/schema.d.ts.map

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

package/dist/subgraphs/budget-statements/schema.js

@@ -15,13 +15,21 @@ export const schema = gql `
   type BudgetStatement {
     id: OID!
     owner: BudgetStatementOwner!
+    operationalHubMember: OperationalHubMember
     month: String! ## JAN2026
     status: String!
     lastModifiedAtUtcIso: DateTime!
+    reportedActuals: Amount_Currency!
+    netExpenseTxns: Amount_Currency!
     snapshotReport: BudgetStatementSnapshotReport!
     expenseReport: BudgetStatementExpenseReport!
   }
 
+  type OperationalHubMember {
+    phid: PHID
+    name: String
+  }
+
   type BudgetStatementOwner {
     id: PHID!
     name: String!